﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace V82.ОбщиеМодули
{
	public partial class ПроцедурыОбменаДанными
	{
		//  ПРОЦЕДУРЫ И ФУНКЦИИ ДЛЯ ОБМЕНА С ИНФОРМАЦИОННЫМИ БАЗАМИ
		//  КОМАНДЫ ГЛАВНОГО КОМАНДНОГО МЕНЮ

		public object ПолучитьПользователяДляОтправкиЭлектронныхСообщений(/**/)
		{
			/*// Выполнение отправки писем фоновым заданием
*/
			return null;
		}
		// УНИВЕРСАЛЬНЫЕ ФУНКЦИИ ЧТЕНИЯ ИЗМЕНЕНИЙ И ЗАГРУЗКИ ИЗМЕНЕНИЙ ДЛЯ ОБМЕНА МЕЖДУ ИНФОРМАЦИОННЫМИ БАЗАМИ ОДИНАКОВОЙ СТРУКТУРЫ
		// Универсальная Процедура чтения изменений из сообщения обмена
		// Применима для случаев когда структура метаданных обменивающихся баз одинакова для всех объектов участвующих в обмене
		//
		// Обязательное условие: У плана обмена должна существовать функция:
		//
		//  Функция ПрименитьИзменениеКИнформационнойБазе(Отправитель, Данные) Экспорт
		//
		// 	Эта функция будет вызываться лишь в том случае, если произошла коллизия изменений. то есть один и тот же объект изменился
		//	в двух узлах информационной базы.
		//
		//	Параметры вспомогательной функции:
		//
		//  	Отправитель - ссылка на план обмена от кого пришло изменение
		//      Данные - непосредственно сами данные, которые пришли от узла отправителя
		//
		//	Возвращаемые параметры вспомогательной функции
		//		Результат - булево. Если истина, то изменения будут приняты от узла отправителя и вставлены в информационную базу. В
		// 		в противном случае изменения будут отклонены
		//
		//
		//	ПАРАМЕТРЫ ФУНКЦИИ
		//		УзелОбмена - узел отправитель, от которого пришли изменения
		//		ЧтениеXML - данные изменений
		//
		//	ВОЗВРАЩАЕМЫЕ ПАРАМЕТРЫ
		//
		//		РЕЗУЛЬТАТ - булево. признак того, что чтение изменений прошло успешно
		//

		public object ЗагрузитьИзмененияДляУзлаИзФайлаОбмена(/*УзелОбмена, КоличествоЭлементовВТранзакцииНаЗагрузкуДанных = 0, ЧтениеXML*/)
		{
			//ЭтотУзелОбмена = ПланыОбмена[ПолучитьИмяПланаОбмена(УзелОбмена)].ЭтотУзел();
			/*// Загрузка из найденного файла
*/
			//ЧтениеСообщения = ПланыОбмена.СоздатьЧтениеСообщения();
			//ЧтениеСообщения.НачатьЧтение(ЧтениеXML);
			if(true/*ЧтениеСообщения.Отправитель <> УзелОбмена*/)
			{
				/*// Сообщение предназначено не для этого узла
*/
				//ВызватьИсключение "Неверный узел в файле обмена данными";
			}
			/*// Удаляем регистрацию изменений для узла отправителя сообщения
*/
			//ПланыОбмена.УдалитьРегистрациюИзменений(ЧтениеСообщения.Отправитель, ЧтениеСообщения.НомерПринятого);
			/*// считаем сколько объектов прочитали
*/
			//КоличествоПрочитанныхОбъектов = 0;
			//КоличествоЗаписанныхОбъектов = 0;
			/*// начинаем транзакцию
*/
			//НачатьТранзакцию();
			//ЭтотУзелОбменаОбъект = Неопределено;
			return null;
		}
		// ПрочитатьИзмененияДляУзла
		// Универсальная Процедура записи изменений для сообщения обмена
		// Применима для случаев когда структура метаданных обменивающихся баз одинакова для всех объектов участвующих в обмене
		//
		//	ПАРАМЕТРЫ ФУНКЦИИ
		//		УзелОбмена - узел получатель, для которого формируется пакет изменений
		//		ЗаписьXML - объект для записи изменений
		//
		//	ВОЗВРАЩАЕМЫЕ ПАРАМЕТРЫ
		//
		//		РЕЗУЛЬТАТ - булево. признак того, что запись изменений прошла успешно
		//

		public object ВыгрузитьИзмененияДляУзлаВФайлОбмена(/*УзелОбмена, КоличествоЭлементовВТранзакцииНаВыгрузкуДанных, ЗаписьXML*/)
		{
			//ЗаписьXML.ЗаписатьОбъявлениеXML();
			/*// Создаем новое сообщение
*/
			//ЗаписьСообщения = ПланыОбмена.СоздатьЗаписьСообщения();
			//ЗаписьСообщения.НачатьЗапись(ЗаписьXML, УзелОбмена);
			/*// считаем количество записанных объектов
*/
			//КоличествоЗаписанныхОбъектов = 0;
			//КоличествоНайденныхДляЗаписиОбъектов = 0;
			/*// начинаем транзакцию
*/
			//НачатьТранзакцию();
			return null;
		}
		// ЗаписатьИзмененияДляУзла
		// СОБЫТИЯ ДЛЯ РЕГИСТРАЦИИ МЕСТА СОЗДАНИЯ ОБЪЕКТА
		///////////////////////////////////////////////////////////////////////////////
		// процедура регистрируем место создания нового объекта информационной базы

		public void ЗарегистрироватьМестоСозданияОбъектаИнформационнойБазы(/*СсылкаНаОбъект, УзелОбмена = Неопределено*/)
		{
			//НаборЗаписейРегистра = РегистрыСведений.ОбъектыИнформационныхБаз.СоздатьНаборЗаписей();
			//НаборЗаписейРегистра.Отбор.Объект.Установить(СсылкаНаОбъект);
			//СтрокаНабора = НаборЗаписейРегистра.Добавить();
			//СтрокаНабора.Объект = СсылкаНаОбъект;
			//СтрокаНабора.УзелОбмена = УзелОбмена;
			//НаборЗаписейРегистра.Записать();
		}
		// обработчик события перед записью документа для регистрации места создания

		public void ПередЗаписьюДокументаРегистрацияОбъектаИнформационнойБазыПередЗаписью(/*Источник, Отказ, РежимЗаписи, РежимПроведения*/)
		{
			/*НужноРегистрироватьМестоСоздания = Источник.ЭтоНовый() 
		И ПараметрыСеанса.СохранятьИнформациюОМестеСозданияОбъектов;*/
			//Источник.ДополнительныеСвойства.Вставить("НужноРегистрироватьМестоСоздания", НужноРегистрироватьМестоСоздания);
		}
		// обработчик события при записи документа для регистрации места создания

		public void ПриЗаписиДокументаРегистрацияОбъектаИнформационнойБазыПриЗаписи(/*Источник, Отказ*/)
		{
			//НужноРегистрироватьМестоСоздания = Ложь;
			//Источник.ДополнительныеСвойства.Свойство("НужноРегистрироватьМестоСоздания", НужноРегистрироватьМестоСоздания);
			if(true/*НужноРегистрироватьМестосоздания <> Истина*/)
			{
			}
			if(true/*Источник.ОбменДанными.Загрузка = Истина
		И ЗначениеЗаполнено(Источник.ОбменДанными.Отправитель)*/)
			{
				/*// обмен с определенным узлом
*/
				//ЗарегистрироватьМестоСозданияОбъектаИнформационнойБазы(Источник.Ссылка, Источник.ОбменДанными.Отправитель);
			}
		}
		///////////////////////////////////////////////////////////////////////////////
		// ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ

		public void ДополнитьМассивПолучателейУзламиАвторегистрации(/*Объект*/)
		{
			//Объект.ОбменДанными.Получатели.АвтоЗаполнение = Ложь;
			//НачальныйМассивУзлов = Новый Массив();
			//Объект.ОбменДанными.Получатели.Заполнить();
		}

		public object ОпределитьНовоеИмяКаталогаДляОбменаДанными(/**/)
		{
			//ВременныйКаталог = КаталогВременныхФайлов();
			//НомерКаталога = 1;
			while(true/*НомерКаталога <= 1000*/)
			{
				//ОчередноеИмяКаталога = ВременныйКаталог + "Каталог обмена " + СтрЗаменить(Строка(НомерКаталога), Символы.НПП, "");
				//ВыбФайл = Новый Файл(ОчередноеИмяКаталога);
				if(true/*НЕ ВыбФайл.Существует()*/)
				{
				}
				//НомерКаталога = НомерКаталога + 1;
			}
			return null;
		}

		public void ЗаполнитьНастройкуОбменаЗначениямиПоУмолчанию(/*НастройкаОбмена*/)
		{
			//НастройкаОбмена.ТипНастройки = Перечисления.ТипыАвтоматическогоОбменаДанными.ОбменЧерезФайловыйРесурс;
			//НастройкаОбмена.КаталогОбменаИнформацией = ОпределитьНовоеИмяКаталогаДляОбменаДанными();
			//НастройкаОбмена.ПроизводитьПриемСообщений = Истина;
			//НастройкаОбмена.ПроизводитьОтправкуСообщений = Истина;
			//НастройкаОбмена.ВыполнятьАрхивациюФайловОбмена = Истина;
			//НастройкаОбмена.ПортFTPСоединения = 21;
			//НастройкаОбмена.ТипИнформационнойБазыДляПодключения = Истина;
			//НастройкаОбмена.АутентификацияWindowsИнформационнойБазыДляПодключения = Ложь;
			//НастройкаОбмена.ВерсияПлатформыИнформационнойБазыДляПодключения = "V81";
			//НастройкаОбмена.КоличествоОбъектовДляФоновогоОбмена = 500;
			//НастройкаОбмена.ПослеОшибкиОтложенногоПроведенияПрекратитьОперации = Истина;
			//НастройкаОбмена.КоличествоОшибокОтложенногоПроведенияДляПрекращенияОперации = 5;
			//НастройкаОбмена.ВыполнитьОтложенноеПроведениеДокументовПоРасписанию = Ложь;
		}

		public void ЗаполнитьНастройкуОбменаWEBЗначениямиПоУмолчанию(/*НастройкаОбмена*/)
		{
			//НастройкаОбмена.ОбменТоварами = Истина;
			//НастройкаОбмена.ОбменЗаказами = Истина;
			//НастройкаОбмена.ВыгружатьТолькоИзменения = Истина;
			//НастройкаОбмена.ВыгружатьНаСайт		 		= Истина;
			//НастройкаОбмена.HTTPОбменИмяПользователя = "User";
			//НастройкаОбмена.HTTPОбменПароль			= "";
			//НастройкаОбмена.ВыгружатьКартинки = Истина;
			//НастройкаОбмена.СпособИдентификацииКонтрагентов	= "Наименование";
			//ТекущийПользователь = ПараметрыСеанса.ТекущийПользователь;
			//ОсновнойКаталогФайлов 		= УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекущийПользователь, "ОсновнойКаталогФайлов");
			if(true/*НЕ ЗначениеЗаполнено(ОсновнойКаталогФайлов)*/)
			{
				//ОсновнойКаталогФайлов = "C:";
			}
			//НастройкаОбмена.КаталогВыгрузки	= ОсновнойКаталогФайлов + "/1cbitrix";
			//НастройкаОбмена.Организация = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекущийПользователь, "ОсновнаяОрганизация");
			if(true/*НЕ ЗначениеЗаполнено(НастройкаОбмена.Организация)*/)
			{
				//Выборка = Справочники.Организации.Выбрать();
				if(true/*Выборка.Следующий()*/)
				{
					//НастройкаОбмена.Организация = Выборка.Ссылка;
				}
			}
			//НастройкаОбмена.Подразделение 					  = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекущийПользователь, "ОсновноеПодразделение");
			//НастройкаОбмена.Ответственный 					  = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекущийПользователь, "ОсновнойОтветственный");
			//НастройкаОбмена.ЕдиницаИзмеренияНовойНоменклатуры = УправлениеПользователями.ПолучитьЗначениеПоУмолчанию(ТекущийПользователь, "ОсновнаяЕдиницаПоКлассификатору");
			if(true/*НЕ ЗначениеЗаполнено(НастройкаОбмена.ЕдиницаИзмеренияНовойНоменклатуры)*/)
			{
				//ЕдиницаИзмеренияНовойНоменклатуры = Справочники.КлассификаторЕдиницИзмерения.НайтиПоНаименованию("шт", Истина);
				if(true/*НЕ ЗначениеЗаполнено(НастройкаОбмена.ЕдиницаИзмеренияНовойНоменклатуры)*/)
				{
					//НастройкаОбмена.ЕдиницаИзмеренияНовойНоменклатуры = Справочники.КлассификаторЕдиницИзмерения.НайтиПоКоду("796");
				}
			}
			//НастройкаОбмена.HTTPОбменАдресСайта	= "http://localhost:6448/bitrix/admin/1c_exchange.php";
		}
		// функция возвращает часть строки после последнего встреченного символа в строке

		public object ПолучитьСтрокуОтделеннойСимволом(/*Знач ИсходнаяСтрока, Знач СимволПоиска*/)
		{
			//ПозицияСимвола = СтрДлина(ИсходнаяСтрока);
			while(true/*ПозицияСимвола >= 1*/)
			{
				if(true/*Сред(ИсходнаяСтрока, ПозицияСимвола, 1) = СимволПоиска*/)
				{
				}
				//ПозицияСимвола = ПозицияСимвола - 1;
			}
			return null;
		}
		// Выделяет из имени файла его расширение (набор символов после последней точки).
		//
		// Параметры
		//  ИмяФайла     – Строка, содержащая имя файла, неважно с именем каталога или без.
		//
		// Возвращаемое значение:
		//   Строка – расширение файла.
		//

		public object ПолучитьРасширениеИмениФайла(/*Знач ИмяФайла*/)
		{
			//Расширение = ПолучитьСтрокуОтделеннойСимволом(ИмяФайла, ".");
			return null;
		}

		public object ПолучитьИмяПротоколаЗагрузки(/*ИмяФайлаПротоколаОбмена*/)
		{
			//РасширениеФайлаПротокола = ПроцедурыОбменаДанными.ПолучитьРасширениеИмениФайла(ИмяФайлаПротоколаОбмена);
			if(true/*Не ПустаяСтрока(РасширениеФайлаПротокола)*/)
			{
				//ИмяФайлаПротоколаЗагрузки = СтрЗаменить(ИмяФайлаПротоколаОбмена, "." + РасширениеФайлаПротокола, "");
			}
			//ИмяФайлаПротоколаЗагрузки = ИмяФайлаПротоколаЗагрузки + "_Загрузка";
			if(true/*Не ПустаяСтрока(РасширениеФайлаПротокола)*/)
			{
				//ИмяФайлаПротоколаЗагрузки = ИмяФайлаПротоколаЗагрузки + "." + РасширениеФайлаПротокола;
			}
			return null;
		}
		//ФОРМА ХОДА ОБРАБОТКИ
		// Процедура показывает новое сообщение в форме хода обработки данных

		public void ОтобразитьНовоеСообщениеВФормеХодаОбработки(/*СтруктураОбменаДанными, Знач ТекстСообщения, Знач ПроцентПрибавления = 0*/)
		{
			//СтруктураОбменаДанными.ФормаХодаВыполненияОбмена.КомментарийОбработкиДанных = ТекстСообщения;
			//СтруктураОбменаДанными.ФормаХодаВыполненияОбмена.Значение = СтруктураОбменаДанными.ФормаХодаВыполненияОбмена.Значение + ПроцентПрибавления;
		}
		// Процедура показывает новое сообщение в форме хода обработки данных

		public void ИнициализироватьФормуХодаОбработки(/*СтруктураОбменаДанными, Знач ТекстСообщения = "", Знач ПроцентПрибавления = 0*/)
		{
			//ФормаХодаВыполненияОбмена = Неопределено;
			//СтруктураОбменаДанными.Свойство("ФормаХодаВыполненияОбмена", ФормаХодаВыполненияОбмена);
			if(true/*ФормаХодаВыполненияОбмена = Неопределено*/)
			{
				//ФормаХодаВыполненияОбмена = ПолучитьОбщуюФорму("ХодВыполненияОбработкиДанных");
				//СтруктураОбменаДанными.Вставить("ФормаХодаВыполненияОбмена", ФормаХодаВыполненияОбмена);
			}
			//ФормаХодаВыполненияОбмена.НаименованиеОбработкиДанных = "Обмен данными по настройке: " + СтруктураОбменаДанными.ДанныеНастройки.Наименование;
			//ФормаХодаВыполненияОбмена.КомментарийОбработкиДанных = ТекстСообщения;
			//ФормаХодаВыполненияОбмена.Значение = ПроцентПрибавления;
			//ФормаХодаВыполненияОбмена.МаксимальноеЗначение = 100;
			if(true/*Не ФормаХодаВыполненияОбмена.Открыта()*/)
			{
				//ФормаХодаВыполненияОбмена.Открыть();
			}
		}
		//Процедура закрывает форму хода обработки данных

		public void ЗакрытьФормуОбработкиДанных(/*СтруктураОбменаДанными*/)
		{
			//ФормаХодаВыполненияОбмена = Неопределено;
			//СтруктураОбменаДанными.Свойство("ФормаХодаВыполненияОбмена", ФормаХодаВыполненияОбмена);
			if(true/*ФормаХодаВыполненияОбмена <> Неопределено*/)
			{
				if(true/*ФормаХодаВыполненияОбмена.Открыта()*/)
				{
					//ФормаХодаВыполненияОбмена.Закрыть();
				}
				//СтруктураОбменаДанными.ФормаХодаВыполненияОбмена = Неопределено;
			}
		}
		// функция нормализует ftp адрес (отрезает не нужное)

		public object НормализоватьFTPАдрес(/*Знач FTPАдрес*/)
		{
			//ИтоговыйАдрес = СокрЛП(FTPАдрес);
			//ПозицияFTP = Найти(Врег(ИтоговыйАдрес), "FTP://");
			if(true/*ПозицияFTP = 1*/)
			{
				//ИтоговыйАдрес = Сред(ИтоговыйАдрес, 7);
			}
			return null;
		}
		// Процедура выполняет удаление файла

		public object ВыполнитьУдалениеФайла(/*Знач ИмяФайлаУдаления, СтруктураНастроекОбменаДанными, 
	Знач ВыводитьИнформациюВПротокол = Ложь, ЭтоВыгрузка = Истина*/)
		{
			if(true/*ПустаяСтрока(ИмяФайлаУдаления)*/)
			{
			}
			return null;
		}
		// Процедура выполняет копирование файла

		public object ВыполнитьКопированиеФайла(/*Знач ИмяФайлаИсточника, Знач ИмяФайлаПриемника, 
	Знач ВыводитьИнформациюВПротокол = Ложь, СтруктураНастроекОбменаДанными, ЭтоВыгрузка = Истина*/)
		{
			return null;
		}
		// Процедура меняет расширение имени файла обмена и выполняет проверку наличия каталога для работы

		public void ПроверитьДоступностьРаботыСКаталогом(/*ИмяФайлаЧтенияИзменений, Знач НужноМенятьРасширениеНаZIP = Ложь*/)
		{
			if(true/*НужноМенятьРасширениеНаZIP*/)
			{
				//РаботаСФайлами.УстановитьРасширениеФайла(ИмяФайлаЧтенияИзменений, ".zip");
			}
			/*//надо убедиться в том что каталог куда все будем сохранять существует
*/
			//СоздатьКаталогПоПолномуПутиКФайлу(ИмяФайлаЧтенияИзменений);
		}
		///////////////////////////////////////////////////////////////////////////////
		// АВТОМАТИЧЕСКОЕ ОБНОВЛЕНИЕ КОНФИГУРАЦИИ
		// функция возвращает настройки для формирования файла обновления конфигурации

		public object ПолучитьНастройкиДляФайлаОбновленияКонфигурации(/**/)
		{
			if(true/*НЕ ПравоДоступа("Чтение", Метаданные.Константы.НастройкаФайлаОбновленияКонфигурации)*/)
			{
			}
			/*// получаем сами настройки
*/
			//НастройкиДляОбновленияКонфигурации = Константы.НастройкаФайлаОбновленияКонфигурации.Получить();
			if(true/*НастройкиДляОбновленияКонфигурации <> Неопределено*/)
			{
			}
			return null;
		}
		// Функция устанавливает настройки для файла обновления конфигурации

		public object УстановитьНастройкиДляФайлаОбновленияКонфигурации(/*СтруктураНастроек*/)
		{
			if(true/*НЕ ПравоДоступа("Изменение", Метаданные.Константы.НастройкаФайлаОбновленияКонфигурации)*/)
			{
				//СообщитьИнформациюОПростойОшибке("Нет прав на изменение константы ""Настройка файла обновления конфигурации""");
			}
			return null;
		}
		// функция создает параметры настроек обновления конфигурации по умолчанию

		public object СоздатьПараметрыНастроекОбновленияКонфигурацииПоУмолчанию(/**/)
		{
			//ПараметрыНастроек = Новый Структура();
			//ПараметрыНастроек.Вставить("ФормироватьФайлОбновленияКонфигурацииАвтоматически", Истина);
			//ПараметрыНастроек.Вставить("АвтоматическиОбновлятьКонфигурациюПриПриемеСообщенияОтГлавногоУзлаРИБ", Ложь);
			//ПараметрыНастроек.Вставить("ИмяАдминистратораИнформационнойБазы", "");
			//ПараметрыНастроек.Вставить("ИмяФайлаДляЗаписиОшибок", "");
			//ПараметрыНастроек.Вставить("ИмяЗапускаПрограммы", "");
			return null;
		}
		// Процедура определяет параметры БАТ файла для обновления конфигурации

		public void СформироватьПараметрыДляОбновленияКонфигурации(/*ИмяПользователяБД, ИмяПрограммыЗапуска, ПутьКБД, ФайловаяБД*/)
		{
			/*// создается BAT файл по установленному макету и запускается
*/
			//СтрокаСоединенияСБД = СтрокаСоединенияИнформационнойБазы();
			//ЭтоФайловаяИБ = ОпределитьЭтаИнформационнаяБазаФайловая(СтрокаСоединенияСБД);
			if(true/*ЭтоФайловаяИБ*/)
			{
				//ПутьКБД = Сред(СтрокаСоединенияСБД, 6, СтрДлина(СтрокаСоединенияСБД) - 6);
				//ФайловаяБД = Истина;
			}
			//ИмяПрограммыЗапуска = РаботаСФайлами.ПолучитьИмяФайла(КаталогПрограммы(), "1cv8.exe");
			//ИмяПользователяБД = ИмяПользователя();
		}
		// Функция формирует логин пользователя для подключения к ИБ

		public object СформироватьЛогинПодключенияКИБ(/*Знач ИмяПользователяБД*/)
		{
			if(true/*Не ПустаяСтрока(ИмяПользователяБД)*/)
			{
				//ТребуетсяАвторизацияОС = ПолныеПрава.НаличиеУПользователяWindowsАвторизации(ИмяПользователяБД);
				//КлючАвторизации = ?(ТребуетсяАвторизацияОС, "/WA+", "/WA-");
				//ПользовательБД = "/N""" + ИмяПользователяБД + """ " + КлючАвторизации;
			}
			return null;
		}
		// Функция формирует часть бат файла (объявления) для обновления конфигурации

		public object СформироватьЧастьОбъявленийПодключенияТекущегоПользователя(/*ИмяПрограммыЗапуска = ""*/)
		{
			//СформироватьПараметрыДляОбновленияКонфигурации(ИмяПользователяБД, ИмяПрограммыЗапускаПоУмолчанию, ПутьКБД, ФайловаяБД);
			if(true/*ПустаяСтрока(ИмяПрограммыЗапуска)*/)
			{
				//ИмяПрограммыЗапуска = ИмяПрограммыЗапускаПоУмолчанию;
			}
			//ТекстФайлаПоУмолчанию = Символы.ПС;
			//ТекстФайлаПоУмолчанию = ТекстФайлаПоУмолчанию + "set v8exe=""" + ИмяПрограммыЗапуска + """" + Символы.ПС;
			//ТекстФайлаПоУмолчанию = ТекстФайлаПоУмолчанию + "set DataBaseName=" + ПутьКБД + Символы.ПС;
			if(true/*ФайловаяБД*/)
			{
				//ТекстФайлаПоУмолчанию = ТекстФайлаПоУмолчанию + "set DataBase=/F%DataBaseName%" + Символы.ПС;
			}
			//ПользовательБД = СформироватьЛогинПодключенияКИБ(ИмяПользователяБД);
			//ТекстФайлаПоУмолчанию = ТекстФайлаПоУмолчанию + "set User=" + ПользовательБД + Символы.ПС;
			return null;
		}
		// функция формирует часть бат файла (вызов обновления конфигурации)

		public object СформироватьЧастьВызоваОбновленияКонфигурации(/*Знач ИмяАдминистратораИБ = "", Знач ИмяФайлаИнформацииОбОшибках = "", 
	Знач ИспользоватьФайлОбОшибкахСПустымИменем = Ложь*/)
		{
			//ИмяЛогинаАдминистратора = ?(ПустаяСтрока(ИмяАдминистратораИБ), "", СформироватьЛогинПодключенияКИБ(ИмяАдминистратораИБ));
			//СтрокаОбъявленияФайлаСообщенийОбОшибках = "";
			//СтрокаДляВыводаДанныхВФайл = "";
			if(true/*НЕ ПустаяСтрока(ИмяФайлаИнформацииОбОшибках) ИЛИ ИспользоватьФайлОбОшибкахСПустымИменем*/)
			{
				/*// надо проверить наличие файла для обмена, есл его нет то создать его
*/
				//СтрокаИмениФайлаИнформацииОбОшибках = СокрЛП(ИмяФайлаИнформацииОбОшибках);
				/*СтрокаОбъявленияФайлаСообщенийОбОшибках = "
			|REM Путь к файлу для ошибок и сообщений
			|set FileInformation=""" + СтрокаИмениФайлаИнформацииОбОшибках + """
			|
			|date /t >> %FileInformation%
			|time /t >> %FileInformation%
			|set DataBaseName>>%FileInformation%";*/
				//СтрокаДляВыводаДанныхВФайл = "/Out%FileInformation% -NoTruncate";
			}
			/*// основной текст
*/
			/*ТекстФайлаПоУмолчанию = "
		|REM Логин администратора системы
		|set AdminUser=" + ИмяЛогинаАдминистратора + "
        |
		|" + СтрокаОбъявленияФайлаСообщенийОбОшибках + " 
		|
		|rem Завершение работы пользователей
		|start """" /wait %v8exe% ENTERPRISE %DataBase% %AdminUser% /CЗавершитьРаботуПользователей	/UCПакетноеОбновлениеКонфигурацииИБ	" + СтрокаДляВыводаДанныхВФайл + " /DisableStartupMessages
        |
		|start """" /wait %v8exe% CONFIG     %DataBase% %AdminUser% /UpdateDBCfg /UCПакетноеОбновлениеКонфигурацииИБ	" + СтрокаДляВыводаДанныхВФайл + "
        |
		|rem Разрешение работы пользователей
		|start """" /wait %v8exe% ENTERPRISE %DataBase% %AdminUser% /CРазрешитьРаботуПользователей	/UCПакетноеОбновлениеКонфигурацииИБ	" + СтрокаДляВыводаДанныхВФайл + " /DisableStartupMessages
        |
		|rem Запуск самой программы
		|start """" %v8exe% ENTERPRISE %DataBase% %User%  /DisableStartupMessages";*/
			return null;
		}
		// Функция формирует текст файла обновления конфигурации по умолчанию

		public object ПолучитьТекстНастроекФайлаОбновленияКонфигурацииПоУмолчанию(/**/)
		{
			//ТекстФайлаПоУмолчанию = СформироватьЧастьОбъявленийПодключенияТекущегоПользователя();
			/*// основной текст
*/
			//ТекстФайлаПоУмолчанию = ТекстФайлаПоУмолчанию + СформироватьЧастьВызоваОбновленияКонфигурации(,,Истина);
			return null;
		}
		// функция формирует текст бат файла обновления конфигурации по структуре данных

		public object СформироватьТекстБатФайлаПоСтруктуре(/*СтруктураПараметров*/)
		{
			//ТекстФайла = "";
			/*// автоматически или нет формируется файл с настройками
*/
			//ФормироватьФайлОбновленияКонфигурацииАвтоматически = Истина;
			//СтруктураПараметров.Свойство("ФормироватьФайлОбновленияКонфигурацииАвтоматически", ФормироватьФайлОбновленияКонфигурацииАвтоматически);
			if(true/*ФормироватьФайлОбновленияКонфигурацииАвтоматически = Истина*/)
			{
				/*// имя администратора информационной базы
*/
				//ИмяАдминистратораИнформационнойБазы = "";
				if(true/*Не СтруктураПараметров.Свойство("ИмяАдминистратораИнформационнойБазы", ИмяАдминистратораИнформационнойБазы)*/)
				{
					//ИмяАдминистратораИнформационнойБазы = "";
				}
				/*// файл для фиксирования ошибок
*/
				//ИмяФайлаДляЗаписиОшибок = "";
				if(true/*Не СтруктураПараметров.Свойство("ИмяФайлаДляЗаписиОшибок", ИмяФайлаДляЗаписиОшибок)*/)
				{
					//ИмяФайлаДляЗаписиОшибок = "";
				}
				//ИмяЗапускаПрограммы = "";
				if(true/*Не СтруктураПараметров.Свойство("ИмяЗапускаПрограммы", ИмяЗапускаПрограммы)*/)
				{
					//ИмяЗапускаПрограммы = "";
				}
				//ТекстФайла = СформироватьЧастьОбъявленийПодключенияТекущегоПользователя(ИмяЗапускаПрограммы);
				//ТекстФайла = ТекстФайла + СформироватьЧастьВызоваОбновленияКонфигурации(ИмяАдминистратораИнформационнойБазы, ИмяФайлаДляЗаписиОшибок);
			}
			return null;
		}
		// формирование текста бат файла обновления конфигурации по настройкам

		public object ПолучитьСтруктуруНастроекФайлаОбновленияКонфигурации(/**/)
		{
			if(true/*НЕ ПравоДоступа("Чтение", Метаданные.Константы.НастройкаФайлаОбновленияКонфигурации)*/)
			{
				//СообщитьИнформациюОПростойОшибке("Нет прав доступа к константе ""Настройка файла обновления конфигурации""");
			}
			//СтруктураНастроек = ПолучитьНастройкиДляФайлаОбновленияКонфигурации();
			if(true/*СтруктураНастроек = Неопределено*/)
			{
				//СтруктураНастроек = СоздатьПараметрыНастроекОбновленияКонфигурацииПоУмолчанию();
			}
			return null;
		}

		public object СформироватьТекстБатФайлаПоНастройкам(/**/)
		{
			//СтруктураНастроек = ПолучитьСтруктуруНастроекФайлаОбновленияКонфигурации();
			//ТекстФайла = СформироватьТекстБатФайлаПоСтруктуре(СтруктураНастроек);
			return null;
		}

		public void ВыполнитьОбновлениеКонфигурацииДляИнформационнойБазы(/*НастройкаОбменаДанными, СтруктураПараметров = Неопределено*/)
		{
			/*// надо для выбранной настройки поставить признак запуска обмена при загрузке данных
*/
			//УстановитьНеобходимостьВыполненияОбменаПриПервомЗапускеПрограммы(НастройкаОбменаДанными, Истина);
			//ПредложитьПерезагрузкуПрограммы(СтруктураПараметров, Истина);
		}
		// Процедура формирование BAT-Файла для автоматической перезагрузки программы
		//

		public void ПредложитьПерезагрузкуПрограммы(/*СтруктураПараметров = Неопределено, 
	Знач ЗапускатьФайлОбновленияКонфигурации = Ложь*/)
		{
			if(true/*СтруктураПараметров = Неопределено*/)
			{
				/*// создается BAT файл по установленному макету и запускается
*/
				//ТекстБатФайла = СформироватьТекстБатФайлаПоНастройкам();
			}
			if(true/*ПустаяСтрока(ТекстБатФайла)*/)
			{
				//СообщитьИнформациюОПростойОшибке("Нельзя создать пустой файл автоматического обновления конфигурации");
			}
			//ТекстовыйДокумент = Новый ТекстовыйДокумент();
			//ТекстовыйДокумент.УстановитьТекст(ТекстБатФайла);
			//ТекстовыйДокумент.Вывод = ИспользованиеВывода.Разрешить;
			//ИмяБАТФайла = РаботаСФайлами.ПолучитьИмяФайла(КаталогВременныхФайлов(), "Upd1C.bat");
			//ТекстовыйДокумент.Записать(ИмяБАТФайла, КодировкаТекста.OEM);
			if(true/*ЗапускатьФайлОбновленияКонфигурации*/)
			{
				//Сообщить("Файл для автоматического изменения конфигурации запущен на исполнение: " + ИмяБАТФайла);
				/*// запускаем БАТ файл перезагрузки
*/
				//ЗапуститьПриложение(ИмяБАТФайла);
				//КомОбъект = Новый COMObject("wScript.Shell");
				//КомОбъект.Run("""" + ИмяБАТФайла + """");
			}
		}
		// ПредложитьПерезагрузкуПрограммы
		///////////////////////////////////////////////////////////////////////////////
		//	ПРОТОКОЛ
		// Процедура дописывает информацию в файл лога

		public void ДобавитьИнформациюВПротокол(/*Знач ИнформацияДляПользователя, ДанныеПротокола = "", 
			Знач ОтобразитьВОкнеСообщений = Ложь, Знач ЭтоОшибка = Ложь*/)
		{
			if(true/*Не ПустаяСтрока(ИнформацияДляПользователя)*/)
			{
				//СтрокаДляЗаписи = "[" + Строка(ТекущаяДата()) + "] " + ИмяПользователя + ИнформацияДляПользователя;
			}
			if(true/*ДанныеПротокола = ""*/)
			{
				//ДанныеПротокола = СтрокаДляЗаписи;
			}
			/*// возможно информацию еще надо в окно сообщений пользователю вывести
*/
			if(true/*ОтобразитьВОкнеСообщений*/)
			{
				if(true/*ЭтоОшибка*/)
				{
					//ОбщегоНазначения.СообщитьОбОшибке(ИнформацияДляПользователя);
				}
			}
		}
		// Процедура отображает сообщение пользователю и записывает его в лог

		public void СообщитьПростуюИнформацию(/*Знач ИнформацияДляПользователя, ДанныеПротокола, 
	Знач ВывестиИнформациюВОкноСообщений = Истина, СтруктураОбменаДанными = Неопределено*/)
		{
			if(true/*СтруктураОбменаДанными = Неопределено*/)
			{
				//ДобавитьИнформациюВПротокол(ИнформацияДляПользователя, ДанныеПротокола, ВывестиИнформациюВОкноСообщений, Ложь);
			}
		}
		// Процедура отображает сообщение об ошибке пользователю и записывает его в лог

		public void СообщитьИнформациюОПростойОшибке(/*Знач ИнформацияДляПользователя, ДанныеПротокола = "", Знач ОтображатьСообщениеОбОшибке = Истина*/)
		{
			//ДобавитьИнформациюВПротокол(ИнформацияДляПользователя, ДанныеПротокола, ОтображатьСообщениеОбОшибке, Истина);
		}
		// функция отражает сообщение об ошибке при обмене данными

		public void СообщитьИнформациюОбОшибкеОбмена(/*Знач ИнформацияДляПользователя, СтруктураОбменаДанными, 
	ЗаписатьИнформациюОбОшибкеВИсторию = Ложь, ЭтоВыгрузкаДанных = Истина*/)
		{
			/*ДобавитьИнформациюВПротокол(ИнформацияДляПользователя, СтруктураОбменаДанными.ДанныеПротокола, 
		СтруктураОбменаДанными.ВывестиИнформациюОбОшибкеВОкноСообщений, Истина);*/
			if(true/*СтруктураОбменаДанными <> Неопределено 
		И ЗаписатьИнформациюОбОшибкеВИсторию*/)
			{
				if(true/*ЭтоВыгрузкаДанных*/)
				{
					//СтруктураОбменаДанными.РезультатЗаписиДанных = Ложь;
				}
				//ДополнитьКомментарийДляОперации(СтруктураОбменаДанными, ИнформацияДляПользователя, ЭтоВыгрузкаДанных);
			}
		}
		// Процедура отображает сообщение пользователю и записывает его в лог

		public void СообщитьИнформациюОбОбмене(/*Знач ИнформацияДляПользователя, СтруктураОбменаДанными*/)
		{
			//ДобавитьИнформациюВПротокол(ИнформацияДляПользователя, СтруктураОбменаДанными.ДанныеПротокола, СтруктураОбменаДанными.ВывестиИнформациюВОкноСообщений, Ложь);
		}
		// Процедура записывает данные протокола

		public void ЗаписатьДанныеПротокола(/*НастройкаОбмена, ДанныеПротокола, ЭтоОшибка = Ложь*/)
		{
			/*// только пустую строку не записываем, все остальное пишем
*/
			if(true/*ДанныеПротокола = ""*/)
			{
			}
			//ТипСообщения = ?(ЭтоОшибка, УровеньЖурналаРегистрации.Ошибка, УровеньЖурналаРегистрации.Информация);
			//ЗаписьЖурналаРегистрации("Обмен данными."+ Строка(НастройкаОбмена.Ссылка), ТипСообщения, , НастройкаОбмена.Ссылка, СокрЛП(ДанныеПротокола));
			/*// очищаем данные протокола обмена
*/
			//ДанныеПротокола = "";
		}
		////////////////////////////////////////////////////////////////////////////////
		// РАБОТА С ФАЙЛАМИ ОБМЕНА
		// функция по двум узлам возвращает имя самого файла обмена информацией, без пути к файлам

		public object СформироватьИмяФайлаОбменаМеждуУзлами(/*УзелОтправитель, УзелПолучатель, Знач РасширениеФайла = ".xml"*/)
		{
			return null;
		}
		// Процедура по полному пути к файлу определяет каталог файла и есл каталог отсутвует то создает его

		public void СоздатьКаталогПоПолномуПутиКФайлу(/*Знач ПолноеИмяФайла*/)
		{
			//ИмяКаталога = "";
			//ИмяФайла = "";
			//РаботаСФайлами.ПолучитьКаталогИИмяФайла(ПолноеИмяФайла, ИмяКаталога, ИмяФайла);
			//СоздатьКаталогВСлучаеОтсутствия(ИмяКаталога);
		}
		// Процедура создает каталог если его нет

		public void СоздатьКаталогВСлучаеОтсутствия(/*Знач ИмяКаталога*/)
		{
			/*// ищем нужный нам каталог, если его нет - то пытаемся создать
*/
			//НаличиеКаталогаОбмена = ПроверитьНаличиеКаталога(ИмяКаталога, Истина);
			if(true/*НЕ НаличиеКаталогаОбмена*/)
			{
				/*// создаем вложенный каталог в темповый
*/
				//СоздатьКаталог(ИмяКаталога);
			}
		}
		// функция возвращает каталог для временных файлов при обмене данными

		public object ПолучитьПутьККаталогуВременныхФайловОбмена(/*Знач НаименованиеНастройкиОбмена, УзелОбмена, Знач ПроверятьНаличиеКаталога = Ложь*/)
		{
			/*// во временном каталоге катаог с именем узла, а потом с именем настройки обмена...
*/
			//ИмяПланаОбмена = ПолучитьИмяПланаОбмена(УзелОбмена);
			//ИмяПланаОбмена = РаботаСФайлами.УдалитьЗапрещенныеСимволыИмени(ИмяПланаОбмена);
			//ПутьКФайлуОбмена = РаботаСФайлами.ПолучитьИмяФайла(КаталогВременныхФайлов(), ИмяПланаОбмена);
			//СтрокаКаталогаОбмена = СокрЛП(РаботаСФайлами.УдалитьЗапрещенныеСимволыИмени(НаименованиеНастройкиОбмена));
			//ПутьКФайлуОбмена = РаботаСФайлами.ПолучитьИмяФайла(ПутьКФайлуОбмена, СтрокаКаталогаОбмена);
			if(true/*ПроверятьНаличиеКаталога*/)
			{
				/*// ищем нужный нам каталог, если его нет - то пытаемся создать
*/
				//СоздатьКаталогВСлучаеОтсутствия(ПутьКФайлуОбмена);
			}
			return null;
		}
		// функция возвращает имя файла обмена между двумя узлами

		public object ВернутьПолныйПутьКФайлуОбменаМеждуУзлами(/*Знач ИмяКаталогаОбмена = "", Знач НаименованиеНастройкиОбмена, УзелОтправитель, УзелПолучатель, 
	Знач ПроверятьНаличиеКаталога = Ложь*/)
		{
			/*// если узел отправитель и получатель совпадают то обмениваться не с кем
*/
			if(true/*УзелОтправитель = УзелПолучатель*/)
			{
			}
			/*// имя итогового каталога обмена
*/
			if(true/*ПустаяСтрока(ИмяКаталогаОбмена)*/)
			{
				//ПутьКФайлуОбмена = ПолучитьПутьККаталогуВременныхФайловОбмена(НаименованиеНастройкиОбмена, УзелОтправитель, ПроверятьНаличиеКаталога);
			}
			/*// Формируем имя временного файла
*/
			//ИмяФайла = РаботаСФайлами.ПолучитьИмяФайла(ПутьКФайлуОбмена, СформироватьИмяФайлаОбменаМеждуУзлами(УзелОтправитель, УзелПолучатель, ".xml"));
			return null;
		}
		// функция возвращает полный путь для создания временного файла обмена данными для записи изменений

		public object ВерутьИмяВременногоФайлаЗаписиДанных(/*СтруктураНастроекОбменаДанными*/)
		{
			//УзелОбмена = СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы;
			/*ИмяФайла = ВернутьПолныйПутьКФайлуОбменаМеждуУзлами(, СтруктураНастроекОбменаДанными.ДанныеНастройки.Наименование,
		ПолучитьТекущийУзелИБ(УзелОбмена), УзелОбмена, Истина);*/
			return null;
		}
		// функция возвращает полный путь временного файла для чтения изменений

		public object ВерутьИмяВременногоФайлаЧтенияДанных(/*СтруктураНастроекОбменаДанными, Знач ИзменитьРасширениеФайлаНаZip*/)
		{
			//УзелОбмена = СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы;
			//ИмяФайла = ВернутьПолныйПутьКФайлуОбменаМеждуУзлами(, СтруктураНастроекОбменаДанными.ДанныеНастройки.Наименование, УзелОбмена, ПолучитьТекущийУзелИБ(УзелОбмена));
			/*// для файла чтения данных важно что бы существовал каталог, откуда будем читать данные
*/
			//ПроверитьДоступностьРаботыСКаталогом(ИмяФайла, ИзменитьРасширениеФайлаНаZip);
			return null;
		}
		// функция проверяет наличие не пустого файла

		public object ПроверитьНаличиеФайлаОбмена(/*Знач ИмяФайлаОбмена*/)
		{
			/*// проверка наличия файла
*/
			//Файл = Новый Файл(ИмяФайлаОбмена);
			if(true/*Не Файл.Существует()*/)
			{
			}
			if(true/*Файл.ЭтоКаталог() ИЛИ Файл.Размер() = 0*/)
			{
			}
			return null;
		}
		// функция проверяет наличие каталога обмена

		public object ПроверитьНаличиеКаталога(/*Знач ИмяКаталога, Знач ПроверятьЧтоНайденныйФайлЭтоКаталог = Ложь*/)
		{
			/*// ищем нужный нам каталог, если его нет - то пытаемся создать
*/
			if(true/*ПустаяСтрока(ИмяКаталога)*/)
			{
			}
			//ВыбФайл = Новый Файл(ИмяКаталога);
			if(true/*Не ВыбФайл.Существует()*/)
			{
			}
			if(true/*ПроверятьЧтоНайденныйФайлЭтоКаталог*/)
			{
				/*// проверка что это точно каталог
*/
			}
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		// ЧТЕНИЕ И ЗАПИСЬ СООБЩЕНИЙ С ИЗМЕНЕНИЯМИ
		// функция создает XMLЗапись для обмена данными

		public object СоздатьXMLЗаписьДляОбменаДанными(/*УзелОбмена, Знач ИмяФайлаОбменаДанными*/)
		{
			if(true/*ПустаяСтрока(ИмяФайлаОбменаДанными)*/)
			{
			}
			/*// Создаем объект записи XML
*/
			//ЗаписьXML = Новый ЗаписьXML;
			return null;
		}
		// функция создает XML чтение по узлу обмена

		public object СоздатьXMLЧтениеДляОбменаДанными(/*УзелОбмена, Знач ИмяФайлаОбменаДанными*/)
		{
			//НаличиеФайлаОбмена = ПроверитьНаличиеФайлаОбмена(ИмяФайлаОбменаДанными);
			if(true/*Не НаличиеФайлаОбмена*/)
			{
			}
			/*// Производим попытку открытия файла
*/
			//ЧтениеXML = Новый ЧтениеXML;
			return null;
		}

		public void УстановитьОбщиеПараметрыДляОбработкиВыгрузкиЗагрузкиДанныхXML(/*ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными, ЭтоВыгрузкаИзТекущейИБ*/)
		{
			//ДанныеНастройки = СтруктураНастроекОбменаДанными.ДанныеНастройки;
			//ОбработкаОбменаДаннымиXML.ВыводВОкноСообщенийИнформационныхСообщений = Ложь;
			//ОбработкаОбменаДаннымиXML.ВыводВПротоколИнформационныхСообщений = ОбработкаОбменаДаннымиXML.ВыводВОкноСообщенийИнформационныхСообщений;
			//ОбработкаОбменаДаннымиXML.ДописыватьДанныеВПротоколОбмена = Истина;
			//ОбработкаОбменаДаннымиXML.ВыгружатьТолькоРазрешенные = Истина;
			//ОбработкаОбменаДаннымиXML.ФлагРежимОтладки = ДанныеНастройки.РежимОтладкиOnLineОбмена;
			//ОбработкаОбменаДаннымиXML.ИспользоватьТранзакцииПриВыгрузкеДляПлановОбмена = (СтруктураНастроекОбменаДанными.КоличествоЭлементовВТранзакцииНаВыгрузкуДанных > 0);
			//ОбработкаОбменаДаннымиXML.КоличествоЭлементовВТранзакцииПриВыгрузкеДляПлановОбмена = СтруктураНастроекОбменаДанными.КоличествоЭлементовВТранзакцииНаВыгрузкуДанных;
			if(true/*ЭтоВыгрузкаИзТекущейИБ*/)
			{
				//ОбработкаОбменаДаннымиXML.ИмяФайлаПротоколаОбмена = ДанныеНастройки.ИмяФайлаПротоколаОбменаOnLineОбмен;
			}
		}

		public void ЗаполнитьТаблицуВыгружаемыхДанных(/*ДеревоПравилВыгрузки, ТаблицаТиповПравилВыгрузки*/)
		{
		}

		public void ПередатьИнформациюВОбработкуОПользовательскихПоляхПоиска(/*ОбработкаОбменаДаннымиXML, СоответствиеПоиска*/)
		{
		}

		public void ИзменитьНастройкиВыгрузкиСогласноДаннымПользователя(/*ОбработкаОбменаДаннымиXML, СоответствиеНастроекВыгрузки*/)
		{
		}

		public void УстановитьПараметрыДляВыгрузкиДанныхXML(/*ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными, ЭтоВыгрузкаИзТекущейИБ = Истина*/)
		{
			//ДанныеНастройки = СтруктураНастроекОбменаДанными.ДанныеНастройки;
			//ОбработкаОбменаДаннымиXML.РежимОбмена = "Выгрузка";
			if(true/*ЭтоВыгрузкаИзТекущейИБ*/)
			{
				//ТекстПравил = ДанныеНастройки.ПравилаОбмена.Получить();
			}
			if(true/*НЕ ПустаяСтрока(ТекстПравил)*/)
			{
				//ОбработкаОбменаДаннымиXML.ЗагрузитьПравилаОбмена(ТекстПравил, "Строка");
			}
			//ОбработкаОбменаДаннымиXML.мПроверятьЗагруженностьПравилПриВыгрузке = Ложь;
			//ОбработкаОбменаДаннымиXML.ДобавлениеОбъектовИзФоновогоОбмена = ДанныеНастройки.ДобавлениеОбъектовИзФоновогоОбмена;
			//ОбработкаОбменаДаннымиXML.КоличествоОбъектовДляФоновогоОбмена = ДанныеНастройки.КоличествоОбъектовДляФоновогоОбмена;
			if(true/*ЭтоВыгрузкаИзТекущейИБ*/)
			{
				//ОбработкаОбменаДаннымиXML.УзелДляФоновогоОбмена = ДанныеНастройки.УзелФоновогоОбмена;
				//ОбработкаОбменаДаннымиXML.УзелДляОбмена = ДанныеНастройки.УзелИнформационнойБазы;
				//ИзменитьНастройкиВыгрузкиСогласноДаннымПользователя(ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными.ИнформацияОбъектовДляВыгрузки);
				//ПередатьИнформациюВОбработкуОПользовательскихПоляхПоиска(ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными.ИнформацияСопоставленияДляВыгрузки);
			}
			//ОбработкаОбменаДаннымиXML.НеВыгружатьОбъектыПоСсылкам = Истина;
			//ОбработкаОбменаДаннымиXML.ИмяФайлаПравилОбмена = "1";
			//ОбработкаОбменаДаннымиXML.мБылиПрочитаныПравилаОбменаПриЗагрузке = Ложь;
			//УстановитьОбщиеПараметрыДляОбработкиВыгрузкиЗагрузкиДанныхXML(ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными, ЭтоВыгрузкаИзТекущейИБ);
		}

		public void ПолучитьТаблицыИнформацииОПравилахОбмена(/*ТекстПравил, ТаблицаНастроекПолей, ТаблицаПравилВыгрузки*/)
		{
			//ОбработкаОбменаДаннымиXML = Обработки.ОбменДаннымиXML.Создать();
			//ОбработкаОбменаДаннымиXML.мРежимЗагрузкиИнформацииОПравилахОбмена = Истина;
			//ОбработкаОбменаДаннымиXML.ИнициализацияТаблицДанныхОПравилахОбмена();
			if(true/*НЕ ПустаяСтрока(ТекстПравил)*/)
			{
				//ОбработкаОбменаДаннымиXML.ЗагрузитьПравилаОбмена(ТекстПравил, "Строка");
			}
			//ТаблицаНастроекПолей = ОбработкаОбменаДаннымиXML.мТаблицаРезультатовЗагрузкиИнформацииОПоляхПоиска;
			//ТаблицаПравилВыгрузки = ОбработкаОбменаДаннымиXML.мТаблицаРезультатовЗагрузкиИнформацииОПравилахВыгрузкиИКонвертации;
		}
		// Процедура записывает изменения узла информационной база в файл в темповом каталоге

		public void ЗаписатьСообщенияСИзмененеиямиДляУзла(/*СтруктураНастроекОбменаДанными, Знач ИмяФайлаОбменаДанными*/)
		{
			//УзелОбмена = СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы;
			//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = Ложь;
			if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.OnLineОбмен*/)
			{
				//ОбработкаОбменаДаннымиXML = Неопределено;
			}
		}
		// Процедура читает файл изменений от узла РИБ

		public void ЗагрузитьCообщениеСИзменениямиОтРИБУзла(/*СтруктураНастроекОбменаДанными, ЧтениеXML, КонфигурацияИзмененаПриОбменеРИБ = ЛОжь*/)
		{
			//СтруктураНастроекОбменаДанными.РезультатЧтенияДанных = Истина;
			//КонфигурацияИзмененаПриОбменеРИБ = Ложь;
			/*// Загрузка из найденного файла
*/
			//ЧтениеСообщения = ПланыОбмена.СоздатьЧтениеСообщения();
			//ЧтениеСообщения.НачатьЧтение(ЧтениеXML);
		}

		public void УстановитьПараметрыДляЗагрузкиДанных(/*ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными*/)
		{
			//ОбработкаОбменаДаннымиXML.РежимОбмена = "Загрузка";
			//УстановитьОбщиеПараметрыДляОбработкиВыгрузкиЗагрузкиДанныхXML(ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными, Истина);
		}
		// Процедура получения сообщения обмена данными
		// Получает сообщение с новыми данными для этого узла и загружает данные
		//

		public void ЗагрузитьСообщениеСИзменениямиДляУзла(/*СтруктураНастроекОбменаДанными, Знач ИмяФайлаОбменаДанными*/)
		{
			//СтруктураНастроекОбменаДанными.РезультатЧтенияДанных = Ложь;
			if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.OnLineОбмен*/)
			{
			}
		}
		// функция возвращает имя плана обмена по узлу обмена

		public object ПолучитьИмяПланаОбмена(/*УзелОбмена*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(УзелОбмена)*/)
			{
			}
			//МетаданныеУзла = УзелОбмена.Метаданные();
			return null;
		}
		// функция возвращает узел текущей ИБ по узлу обмена

		public object ПолучитьТекущийУзелИБ(/*УзелОбмена*/)
		{
			//ИмяПланаОбмена = ПолучитьИмяПланаОбмена(УзелОбмена);
			if(true/*НЕ ЗначениеЗаполнено(ИмяПланаОбмена)*/)
			{
			}
			return null;
		}
		// функция по узлу обмена определяет это база РИБ или нет

		public object ОпределитьПоУзлуОбменаЭтоРИБ(/*УзелОбмена*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(УзелОбмена)*/)
			{
			}
			//МетаданныеПланаОбмена = УзелОбмена.Метаданные();
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		// ВЫБОР КАТАЛОГОВ И ФАЙЛОВ ОБМЕНА ДАННЫМИ
		// функция возвращает выбранный пользователем каталог для выгрузки данных

		public object ВернутьВыбранныйПользователемКаталогДляОбмена(/*КаталогОбмена = ""*/)
		{
			/*// хотят только изменения выгрузить
*/
			//РезультатВыбора = РаботаСФайлами.ВыбратьКаталог(КаталогОбмена, "Выбор каталога обмена данными");
			if(true/*Не РезультатВыбора*/)
			{
				//КаталогОбмена = "";
			}
			return null;
		}
		// Функция запрашивает у пользователя ввести имя файла для обмена данными либо имя каталога для выгрузки данных

		public object ОпроситьИмяКаталогаОбменаДанными(/*Знач ТекстИнформационногоСообщения = "",
	СтруктураНастроекОбменаДанными, КаталогОбмена*/)
		{
			if(true/*Не ПустаяСтрока(ТекстИнформационногоСообщения)*/)
			{
				//СообщитьИнформациюОбОбмене(ТекстИнформационногоСообщения, СтруктураНастроекОбменаДанными);
			}
			/*// не задан каталог обмена данными
*/
			if(true/*НЕ СтруктураНастроекОбменаДанными.РучнойРежимЗапуска*/)
			{
			}
			/*// запуск в интерактивном режиме
*/
			//КаталогОбмена = ВернутьВыбранныйПользователемКаталогДляОбмена(КаталогОбмена);
			return null;
		}
		// АРХИВАЦИЯ
		///////////////////////////////////////////////////////////////////////////////
		// функция архивирует файл

		public object ЗаархивироватьФайл(/*Знач ИмяИсходногоФайла, СтруктураНастроекОбменаДанными*/)
		{
			return null;
		}
		// функция разархивирует файл

		public object РазархивироватьФайл(/*СтруктураНастроекОбменаДанными*/)
		{
			//КаталогДляРаспаковки = КаталогВременныхФайлов();
			//ИмяРазархивированногоФайла = "";
			/*ДобавитьИнформациюВПротокол("Окончание распаковки файла обмена данными " + СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений + ".
		|Распакованные данные помещены в файл " + ИмяРазархивированногоФайла, СтруктураНастроекОбменаДанными.ДанныеПротокола);*/
			return null;
		}
		///////////////////////////////////////////////////////////////////////////////
		//	ОБМЕН ИНФОРМАЦИЕЙ

		public void ОптравитьСообщениеОбОшибкеДействийСОтложеннымПроведениемДокументов(/*СтруктураНастроекОбменаДанными, ТекстСообщения*/)
		{
			if(true/*ПустаяСтрока(ТекстСообщения)*/)
			{
			}
			//ОтправитьСообщениеОбОшибкеОбменаПриНеобходимости(СтруктураНастроекОбменаДанными, , ТекстСообщения);
		}

		public void ОтправитьСообщениеОбОшибкеОбменаПриНеобходимости(/*СтруктураНастроекОбменаДанными, ОшибкаПриВыгрузке = Неопределено, ТекстСообщения = ""*/)
		{
			if(true/*НЕ (ЗначениеЗаполнено(СтруктураНастроекОбменаДанными.ДанныеНастройки.УчетнаяЗаписьОтправкиСообщенияОбОшибке)
		И ЗначениеЗаполнено(СтруктураНастроекОбменаДанными.ДанныеНастройки.АдресДляОтправкиСообщенийОбОшибке))*/)
			{
			}
			//ТекстОшибки = ТекстСообщения;
			if(true/*ПустаяСтрока(ТекстОшибки)*/)
			{
				//ТекстОшибкиПриВыгрузке = "";
				//ТекстОшибкиПриЗагрузке = "";
				//СтруктураНастроекОбменаДанными.Свойство("КомментарийПриВыгрузкеДанных", ТекстОшибкиПриВыгрузке);
				//СтруктураНастроекОбменаДанными.Свойство("КомментарийПриЗагрузкеДанных", ТекстОшибкиПриЗагрузке);
				if(true/*ОшибкаПриВыгрузке = Неопределено*/)
				{
					//ТекстОшибки = СокрЛП(ТекстОшибкиПриЗагрузке) + Символы.ПС + СокрЛП(ТекстОшибкиПриВыгрузке);
				}
				//ТекстОшибки = СокрЛП(ТекстОшибки);
			}
			if(true/*ПустаяСтрока(ТекстОшибки)*/)
			{
			}
			//ВРегТекстОшибки = ВРЕГ(ТекстОшибки);
			/*// определим нет ли в тексте ошибки строки, которая не считается ошибкой
*/
			/*// все проверки пройдены, нужно письмо отсылать
*/
		}
		// Процедура производит чтение данных

		public void ВыполнитьЗагрузкуДанныхИзФайлаОбмена(/*СтруктураНастроекОбменаДанными*/)
		{
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Загрузка данных из файла обмена", 5);
			//СтруктураНастроекОбменаДанными.РезультатЧтенияДанных = Ложь;
			//СтруктураНастроекОбменаДанными.ДатаНачалаЗагрузки = ТекущаяДата();
			/*// ЧТЕНИЕ
*/
			if(true/*НЕ СтруктураНастроекОбменаДанными.ПроизводитьЧтениеДанных*/)
			{
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Загрузка данных из файла обмена", 40);
			}
			if(true/*ПустаяСтрока(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений)*/)
			{
				//СообщитьИнформациюОбОбмене("Не найден входящий файл обмена данными.", СтруктураНастроекОбменаДанными);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, "Не найден входящий файл обмена данными.", Ложь);
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Загрузка данных из файла обмена", 40);
			}
			/*// если расширение файла для чтения ZIP то его нужно сначала разархивировать
*/
			//РасширениеФайлаОбмена = РаботаСФайлами.ПолучитьРасширениеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений);
			//ЧтениеИзАрхива = Врег(РасширениеФайлаОбмена) = "ZIP";
			if(true/*ЧтениеИзАрхива*/)
			{
				//ИмяВременногоФайла = РазархивироватьФайл(СтруктураНастроекОбменаДанными);
			}
			/*// читаем сообщения с изменененями
*/
			if(true/*ИмяВременногоФайла = ""*/)
			{
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Загрузка данных из файла обмена", 40);
			}
			//ЗагрузитьСообщениеСИзменениямиДляУзла(СтруктураНастроекОбменаДанными, ИмяВременногоФайла);
			/*// сообщим о результатах чтения данных
*/
			if(true/*СтруктураНастроекОбменаДанными.РезультатЧтенияДанных*/)
			{
				//СообщитьИнформациюОбОбмене("Чтение данных из файла обмена успешно завершено.", СтруктураНастроекОбменаДанными);
			}
			/*// временный файл откуда считывались данные в любом случае не нужен	
*/
			if(true/*ЧтениеИзАрхива*/)
			{
				//ВыполнитьУдалениеФайла(ИмяВременногоФайла, СтруктураНастроекОбменаДанными, , Ложь);
			}
			/*// запоминаем последнюю дату чтения данных
*/
			//СтруктураНастроекОбменаДанными.ДатаПоследнейЗагрузки = ТекущаяДата();
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Загрузка данных из файла обмена", 40);
		}
		// Процедура производит запись данных

		public void ВыполнитьВыгрузкуДанныхВФайлОбмена(/*СтруктураНастроекОбменаДанными*/)
		{
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Выгрузка данных в файл обмена", 5);
			//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = Ложь;
			//СтруктураНастроекОбменаДанными.ДатаНачалаВыгрузки = ТекущаяДата();
			/*// ЗАПИСЬ
*/
			if(true/*Не СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных*/)
			{
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Выгрузка данных в файл обмена", 40);
			}
			if(true/*ПустаяСтрока(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений)*/)
			{
				//СообщитьИнформациюОбОбмене("Выгрузка изменений из текущей информационной базы НЕ произведена!", СтруктураНастроекОбменаДанными);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, "Выгрузка изменений из текущей информационной базы НЕ произведена!", Истина);
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Выгрузка данных в файл обмена", 40);
			}
			/*// если идет архивирование файла, то надо сначала в темповый файл записать изменения а потом их зархивировать
*/
			if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.ВыполнятьАрхивациюФайловОбмена*/)
			{
				//ИмяФайлаДляЗаписиИзменений = ПолучитьИмяВременногоФайла(".xml");
			}
			/*// записываем изменения
*/
			//ЗаписатьСообщенияСИзмененеиямиДляУзла(СтруктураНастроекОбменаДанными, ИмяФайлаДляЗаписиИзменений);
			/*// если надо то архивируем
*/
			if(true/*СтруктураНастроекОбменаДанными.РезультатЗаписиДанных
		И СтруктураНастроекОбменаДанными.ДанныеНастройки.ВыполнятьАрхивациюФайловОбмена*/)
			{
				//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = ЗаархивироватьФайл(ИмяФайлаДляЗаписиИзменений, СтруктураНастроекОбменаДанными);
				if(true/*СтруктураНастроекОбменаДанными.РезультатЗаписиДанных*/)
				{
					/*// грохаем временный файл
*/
					//ВыполнитьУдалениеФайла(ИмяФайлаДляЗаписиИзменений, СтруктураНастроекОбменаДанными, , Истина);
				}
			}
			/*// сообщим о результатах чтения данных
*/
			if(true/*СтруктураНастроекОбменаДанными.РезультатЗаписиДанных*/)
			{
				//СообщитьИнформациюОбОбмене("Запись изменений текущей информационной базы в файл обмена завершилась успешно.", СтруктураНастроекОбменаДанными);
			}
			//СтруктураНастроекОбменаДанными.ДатаПоследнейВыгрузки = ТекущаяДата();
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Выгрузка данных в файл обмена", 40);
		}
		// функция возвращает дату файла последнего обмена для настройки обмена

		public object ПолучитьДатуФайлаПоследнейЗагрузкиДанных(/*СсылкаНастройкиОбмена*/)
		{
			//Запрос = Новый Запрос();
			/*Запрос.Текст = "ВЫБРАТЬ
	               |	ПараметрыОбменаДанными.ДатаПоследнегоФайлаОбмена
				   |ИЗ
	               |	РегистрСведений.ПараметрыОбменаДанными КАК ПараметрыОбменаДанными
				   |	ГДЕ (ПараметрыОбменаДанными.НастройкаОбменаДанными = &Ссылка)";*/
			//Запрос.УстановитьПараметр("Ссылка", СсылкаНастройкиОбмена);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий()*/)
			{
			}
			return null;
		}
		// Процедура по адресу FTP обмена получает имя сервера и имя каталога обмена

		public void ПолучитьИмяСервераИИмяКаталогаОбмена(/*Знач ПолныйFTPАдрес, ИмяСервера, ИмяКаталога*/)
		{
			//АдресОбмена = НормализоватьFTPАдрес(ПолныйFTPАдрес);
			/*// принцип получения адреса такой, все что до первой черты / или \ - это имя сервера, потом каталог
*/
			//АдресОбмена = СтрЗаменить(АдресОбмена, "\", "/");
			//ПозицияПрямогоСлеша = Найти(АдресОбмена, "/");
			if(true/*ПозицияПрямогоСлеша = 0*/)
			{
				//ИмяСервера = АдресОбмена;
				//ИмяКаталога = "";
			}
		}
		// функция выполняет FTP подключение к серверу

		public object ВыполнитьFTPПодключениеКСерверу(/*Знач ИмяFTPСервера, НастройкиОбмена, 
	ДанныеПротокола = "", Знач ВывестиИнформациюВОкноСообщений = Истина, СтруктураОбменаДанными = Неопределено*/)
		{
			//Состояние("Выполняется подключение к FTP: " + ИмяFTPСервера);
			return null;
		}
		// функция проверяет наличие катаога на FTP сервере

		public object ПроверитьНаличиеКаталогаНаFTPСервере(/*Соединение, Знач ИмяКаталогаСервера, 
	ДанныеПротокола = "", Знач ВывестиИнформациюВОкноСообщений = Истина, СтруктураОбменаДанными = Неопределено*/)
		{
			if(true/*ПустаяСтрока(ИмяКаталогаСервера)*/)
			{
			}
			/*//надо сначала проверить что сам каталог доступа есть
*/
			/*// если не найден каталог для обмена
*/
			/*СообщитьПростуюИнформацию("Не найден FTP каталог обмена информацией: " + ИмяКаталогаСервера, 
		ДанныеПротокола, ВывестиИнформациюВОкноСообщений, СтруктураОбменаДанными);*/
			return null;
		}
		// функция проверяет настройки FTP подключения

		public object ПроверитьНастройкиFTPПодключения(/*ДанныеНастройки, ДанныеПротокола = "", Знач ВывестиИнформациюВОкноСообщений = Истина,
	ИмяКаталогаСервера = "", ИмяFTPСервера = "" , Соединение = Неопределено, СтруктураОбменаДанными = Неопределено*/)
		{
			/*// нужно по полному имени получить имя сервера и имя каталога
*/
			//ПолучитьИмяСервераИИмяКаталогаОбмена(ДанныеНастройки.FTPАдресОбмена, ИмяFTPСервера, ИмяКаталогаСервера);
			/*// если не задано имя сервера или каталога то невозможно обмениваться данными
*/
			if(true/*ПустаяСтрока(ИмяFTPСервера)*/)
			{
				/*СообщитьПростуюИнформацию("Не задан сервер обмена информацией через FTP.", 
			ДанныеПротокола, ВывестиИнформациюВОкноСообщений, СтруктураОбменаДанными);*/
			}
			/*// соединение
*/
			//Соединение = ВыполнитьFTPПодключениеКСерверу(ИмяFTPСервера, ДанныеНастройки, ДанныеПротокола, ВывестиИнформациюВОкноСообщений, СтруктураОбменаДанными);
			if(true/*Соединение = Неопределено*/)
			{
			}
			/*// каталог проверяем
*/
			//НаличиеКаталога = ПроверитьНаличиеКаталогаНаFTPСервере(Соединение, ИмяКаталогаСервера, ДанныеПротокола, ВывестиИнформациюВОкноСообщений, СтруктураОбменаДанными);
			if(true/*Не НаличиеКаталога*/)
			{
			}
			return null;
		}
		// СЛУЖЕБНЫЕ ФУНКЦИЯ ВЫПОЛНЯЮЩИЕСЯ ПЕРЕД ОБМЕНОМ
		///////////////////////////////////////////////////////////////////////////////
		// Процедура подготавливает обмен через файловый ресурс по настройке обмена данными

		public void ПодготовитьОбменЧерезФайловыйРесурс(/*СтруктураНастроекОбменаДанными*/)
		{
			/*//Алгоритм получения файлов обмена:
*/
			/*//Случай автоматического запуска обмена:
*/
			/*//•	Проверка доступности указанного в настройках каталога. Если каталог не доступен (не найден), то обмен не начинается
*/
			/*//•	Проверка наличия файла обмена от узла информационной базы
*/
			/*//•	После внесений изменений в информационную базу файл обмена удаляется
*/
			/*//Случай запуска обмена в ручном режиме:
*/
			/*//•	Проверка доступности указанного в настройках каталога. 
*/
			/*//o	Если искомый каталог доступен и файл обмена в нем присутствует, то обмен происходит точно так же как и при автоматическом запуске
*/
			/*//o	Если каталог не доступен или не найден, либо не найден файл обмена данными то пользователю выдается соответствующее сообщение. Предлагается выбрать файл для обмена самостоятельно.
*/
			//ИтоговоеИмяФайлаОбменаДанными = "";
			//СтруктураНастроекОбменаДанными.КаталогПроведенияОбменаДанными = "";
			//КаталогОбменаДанными = СтруктураНастроекОбменаДанными.ДанныеНастройки.КаталогОбменаИнформацией;
			//ПроверкаНаличияКаталога = ПроверитьНаличиеКаталога(КаталогОбменаДанными, Истина);
			if(true/*НЕ ПроверкаНаличияКаталога*/)
			{
				/*// не задан каталог обмена данными
*/
				if(true/*ПустаяСтрока(КаталогОбменаДанными)*/)
				{
					//ТекстСообщенияПользователю = "Не задан каталог обмена информацией";
				}
				/*РезультатВыбора = ОпроситьИмяКаталогаОбменаДанными(ТекстСообщенияПользователю, СтруктураНастроекОбменаДанными, 
			КаталогОбменаДанными);*/
				if(true/*Не РезультатВыбора*/)
				{
				}
			}
			/*// каталог есть, поверяем наличие файла обмена, если нужно данные считать
*/
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЧтениеДанных*/)
			{
				//ИмяФайлаШаблонаОбмена = СформироватьИмяФайлаОбменаМеждуУзлами(СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы, СтруктураНастроекОбменаДанными.ТекущийУзелПланаОбмена, "");
				//ИмяФайлаПоУмолчаниюXML = ИмяФайлаШаблонаОбмена + ".xml";
				//ИмяФайлаПоУмолчаниюZIP = ИмяФайлаШаблонаОбмена + ".zip";
				//ИтоговоеИмяФайлаОбменаДаннымиXML = РаботаСФайлами.ПолучитьИмяФайла(КаталогОбменаДанными, ИмяФайлаПоУмолчаниюXML);
				//НаличиеФайлаОбменаXML = ПроверитьНаличиеФайлаОбмена(ИтоговоеИмяФайлаОбменаДаннымиXML);
				//ИтоговоеИмяФайлаОбменаДаннымиZIP = РаботаСФайлами.ПолучитьИмяФайла(КаталогОбменаДанными, ИмяФайлаПоУмолчаниюZIP);
				//НаличиеФайлаОбменаZIP = ПроверитьНаличиеФайлаОбмена(ИтоговоеИмяФайлаОбменаДаннымиZIP);
				if(true/*НЕ НаличиеФайлаОбменаXML И НЕ НаличиеФайлаОбменаZIP*/)
				{
					/*// каталог есть, но файлов в нем, удовлетворяющих условиям поиска нет
*/
					/*// значит просто файл не нашли, вот и все.
*/
				}
				/*// наличие файлов приема
*/
			}
			/*// производить прием сообщений
*/
			/*// ничего не указано
*/
			if(true/*ПустаяСтрока(ИтоговоеИмяФайлаОбменаДанными) 
		И ПустаяСтрока(КаталогОбменаДанными)*/)
			{
			}
			//ИнициализироватьФормуХодаОбработки(СтруктураНастроекОбменаДанными, "Подготовка перед обменом данными", 5);
			/*// если задана переменная ИтоговоеИмяФайлаОбменаДанными тогда хотим и изменение получить и данные выгрузить
*/
			if(true/*Не ПустаяСтрока(ИтоговоеИмяФайлаОбменаДанными)*/)
			{
				/*// получаем дату последнего файла обмена
*/
				//СтруктураНастроекОбменаДанными.ДатаПоследнегоФайлаОбмена = РаботаСФайлами.ПолучитьДатуФайла(ИтоговоеИмяФайлаОбменаДанными);
				//СтруктураНастроекОбменаДанными.ИмяВходящегоФайлаОбмена = ИтоговоеИмяФайлаОбменаДанными;
				/*// копируем файл во временный каталог
*/
				/*СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений = ВерутьИмяВременногоФайлаЧтенияДанных(СтруктураНастроекОбменаДанными, 
			(Врег(РаботаСФайлами.ПолучитьРасширениеФайла(ИтоговоеИмяФайлаОбменаДанными)) = "ZIP"));*/
				/*УдачноеКопирование = ВыполнитьКопированиеФайла(ИтоговоеИмяФайлаОбменаДанными, СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений, Истина, 
			СтруктураНастроекОбменаДанными, Ложь);*/
				if(true/*Не УдачноеКопирование*/)
				{
					//СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений	= "";
				}
				//ИмяФайла = "";
				//РаботаСФайлами.ПолучитьКаталогИИмяФайла(ИтоговоеИмяФайлаОбменаДанными, КаталогОбменаДанными, ИмяФайла);
			}
			//СтруктураНастроекОбменаДанными.НеобходимостьЗаписиОтветногоФайлаОбмена = СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных;
			/*// весь обмен производим во временном каталоге
*/
			//СтруктураНастроекОбменаДанными.КаталогПроведенияОбменаДанными = КаталогОбменаДанными;
		}
		// Процедура подготавливает обмен через FTP ресурс по настройке обмена данными

		public void ПодготовитьОбменЧерезFTPРесурс(/*СтруктураНастроекОбменаДанными*/)
		{
			/*ПроверитьНастройкиПодключения = ПроверитьНастройкиFTPПодключения(СтруктураНастроекОбменаДанными.ДанныеНастройки, 
		СтруктураНастроекОбменаДанными.ДанныеПротокола,	СтруктураНастроекОбменаДанными.ВывестиИнформациюВОкноСообщений, 
		ИмяКаталогаСервера, ИмяFTPСервера, Соединение, СтруктураНастроекОбменаДанными);*/
			if(true/*Не ПроверитьНастройкиПодключения*/)
			{
			}
			//СтруктураНастроекОбменаДанными.НеобходимостьЗаписиОтветногоФайлаОбмена = СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных;
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЧтениеДанных*/)
			{
				/*// ищем файлы по маске с расширением Message_A_B .xml или .zip
*/
				/*ШаблонИмениФайла = СформироватьИмяФайлаОбменаМеждуУзлами(СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы, 
			СтруктураНастроекОбменаДанными.ТекущийУзелПланаОбмена, "") + ".*";*/
				//МассивНайденныхФайлов = Соединение.НайтиФайлы(ИмяКаталогаСервера, ШаблонИмениФайла);
				//СтруктураНастроекОбменаДанными.ДатаПоследнегоФайлаОбмена = ПолучитьДатуФайлаПоследнейЗагрузкиДанных(СтруктураНастроекОбменаДанными.ДанныеНастройки.Ссылка);
				/*//надо переместить нужный файл в каталог для обмена данными
*/
				if(true/*ФайлДляОбмена <> Неопределено*/)
				{
					/*СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений = ВерутьИмяВременногоФайлаЧтенияДанных(СтруктураНастроекОбменаДанными, 
				(Врег(ФайлДляОбмена.Расширение) = ".ZIP"));*/
				}
			}
			/*// надо читать данные с FTP	
*/
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных
		ИЛИ Не ПустаяСтрока(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений)*/)
			{
				//ИнициализироватьФормуХодаОбработки(СтруктураНастроекОбменаДанными, "Подготовка перед обменом данными", 5);
			}
		}
		// Процедура подготавливает обмен через почтовый ресурс по настройке обмена данными

		public void ПодготовитьОбменЧерезПочтовыйРесурс(/*СтруктураНастроекОбменаДанными*/)
		{
			//ТекстОшибок = "";
			/*// обмен через почту может быть только в режиме работы клиента
*/
			if(true/*НЕ ЗначениеЗаполнено(СтруктураНастроекОбменаДанными.ДанныеНастройки.УчетнаяЗаписьПриемаОтправкиСообщений)*/)
			{
				//СообщитьИнформациюОбОбмене("Не задана учетная запись приема и отправки сообщений!", СтруктураНастроекОбменаДанными);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, "Не задана учетная запись приема и отправки сообщений!", Истина);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, "Не задана учетная запись приема и отправки сообщений!", Ложь);
			}
			/*// надо проверить есть ли доступные учетные записи для отправки у текущего пользователя
*/
			//СписокДоступныхЗаписей = УправлениеЭлектроннойПочтой.ПолучитьДоступныеУчетныеЗаписи(ПолучитьПользователяДляОтправкиЭлектронныхСообщений()).Запись;
			if(true/*СписокДоступныхЗаписей.Количество() = 0*/)
			{
				/*// отправлять и принимать неоткуда
*/
				//СообщитьИнформациюОбОбмене("Нет доступных учетных записей для отправки и приема сообщений!", СтруктураНастроекОбменаДанными);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, "Нет доступных учетных записей для отправки и приема сообщений!", Истина);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, "Нет доступных учетных записей для отправки и приема сообщений!", Ложь);
			}
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЧтениеДанных*/)
			{
				/*// для ручного режима надо почту получить
*/
				if(true/*СтруктураНастроекОбменаДанными.РучнойРежимЗапуска 
			ИЛИ СтруктураНастроекОбменаДанными.ДанныеНастройки.АвтоматическиЗакачиватьПочтуПриОбмене*/)
				{
					//СообщитьИнформациюОбОбмене("Получение почтовых сообщений", СтруктураНастроекОбменаДанными);
					if(true/*НЕ ПустаяСтрока(ТекстОшибок)*/)
					{
						//СообщитьИнформациюОбОшибкеОбмена("Ошибка при получении почтовых сообщений: " + ТекстОшибок, СтруктураНастроекОбменаДанными, Истина, Ложь);
					}
				}
				/*// ищем файлы по маске с расширением Message_A_B .xml или .zip
*/
				//ИмяШаблонаОбмена = СформироватьИмяФайлаОбменаМеждуУзлами(СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы, СтруктураНастроекОбменаДанными.ТекущийУзелПланаОбмена, "");
				//ШаблонИмениФайлаXML = ИмяШаблонаОбмена + ".xml";
				//ШаблонИмениФайлаZIP = ИмяШаблонаОбмена + ".zip";
				/*// проверяем все непрочитанные письма для учетной записи
*/
				//Запрос = Новый Запрос();
				/*Запрос.Текст = 
			"ВЫБРАТЬ
		   |	ВложенияЭлектронныхПисем.ИмяФайла,
		   |	ВложенияЭлектронныхПисем.Хранилище,
		   |	ЭлектронноеПисьмо.ДатаОтправления,
		   |	ЭлектронноеПисьмо.Ссылка
		   |ИЗ
		   |	Справочник.ВложенияЭлектронныхПисем КАК ВложенияЭлектронныхПисем
		   |	ВНУТРЕННЕЕ СОЕДИНЕНИЕ Документ.ЭлектронноеПисьмо КАК ЭлектронноеПисьмо
		   |		ПО (ЭлектронноеПисьмо.Ссылка = ВложенияЭлектронныхПисем.Объект) 
		   |			И (ЭлектронноеПисьмо.НеРассмотрено = ИСТИНА) 
		   |			И (ЭлектронноеПисьмо.СтатусПисьма = &Входящее)
		   |
		   |	ГДЕ (ВложенияЭлектронныхПисем.ИДФайлаПочтовогоПисьма = """" )
		   |		И (ЭлектронноеПисьмо.Тема = &ИмяШаблонаОбмена)
		   |		И (
		   |			(ВложенияЭлектронныхПисем.ИмяФайла Подобно &ИмяФайлаXML)
		   |			ИЛИ (ВложенияЭлектронныхПисем.ИмяФайла Подобно &ИмяФайлаZIP)
		   |		   )
		   |
		   |	УПОРЯДОЧИТЬ ПО ЭлектронноеПисьмо.ДатаОтправления УБЫВ	
		   |";*/
				//Запрос.УстановитьПараметр("ИмяФайлаXML", "%" + ШаблонИмениФайлаXML + "%");
				//Запрос.УстановитьПараметр("ИмяФайлаZIP", "%" + ШаблонИмениФайлаZIP + "%");
				//Запрос.УстановитьПараметр("ИмяШаблонаОбмена", ИмяШаблонаОбмена);
				//Запрос.УстановитьПараметр("Входящее", Перечисления.СтатусыПисем.Полученное);
				//ТаблицаФайлов = Запрос.Выполнить().Выгрузить();
				/*// надо по найденным вложениям пробежать и взять первый подходящий файл для выгрузки
*/
				/*// записываем на диск только файл с наибольшей датой отправления
*/
				//ФайлЗаписанНаДиск = Ложь;
				/*// не нашли файл
*/
				if(true/*ФайлЗаписанНаДиск*/)
				{
				}
			}
			/*// ПроизводитьПриемСообщений	
*/
			/*// если не указан адрес отправки сообщений, то не формируем результирующий файл
*/
			/*СтруктураНастроекОбменаДанными.НеобходимостьЗаписиОтветногоФайлаОбмена = СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных
		И (ЗначениеЗаполнено(СтруктураНастроекОбменаДанными.ДанныеНастройки.ПочтовыйАдресПолучателя));*/
			/*// что то надо делать	
*/
			if(true/*СтруктураНастроекОбменаДанными.НеобходимостьЗаписиОтветногоФайлаОбмена
		ИЛИ Не ПустаяСтрока(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений)*/)
			{
				//ИнициализироватьФормуХодаОбработки(СтруктураНастроекОбменаДанными, "Подготовка перед обменом данными", 5);
			}
		}
		// СЛУЖЕБНЫЕ ФУНКЦИЯ ВЫПОЛНЯЮЩИЕСЯ ПОСЛЕ ОБМЕНА
		///////////////////////////////////////////////////////////////////////////////
		//Процедура удаляет не нужные файлы после обмена данными

		public void УдалитьФайлПослеОбменаДанными(/*СтруктураНастроекОбменаДанными*/)
		{
			if(true/*ОпределитьБылоУдачноПроизведеноЧтениеДанных(СтруктураНастроекОбменаДанными)
		И (Не СтруктураНастроекОбменаДанными.РучнойРежимЗапуска)*/)
			{
				//ВыполнитьУдалениеФайла(СтруктураНастроекОбменаДанными.ИмяВходящегоФайлаОбмена, СтруктураНастроекОбменаДанными, Истина, Ложь);
			}
			/*// временный файл для чтения данных надо грохнуть вне зависимости от результатов чтения
*/
			//ВыполнитьУдалениеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений, СтруктураНастроекОбменаДанными, , Ложь);
		}
		//Функция по структуре возвращает была ли произведена запись данных

		public object ОпределитьБылаУдачнноПроизведенаЗаписьДанных(/*СтруктураНастроекОбменаДанными*/)
		{
			return null;
		}
		//Функция по структуре возвращает было ли произведено чтение данных

		public object ОпределитьБылоУдачноПроизведеноЧтениеДанных(/*СтруктураНастроекОбменаДанными*/)
		{
			return null;
		}
		// функция определяет нужно опправлять ответный пакет или нет

		public object ОпределитьНужноОптравлятьОтветныйПакет(/*СтруктураНастроекОбменаДанными, НужноПроверитьЧерезПочту*/)
		{
			/*МаксимальныйДопустимыйРазмерСообщения = ?(НужноПроверитьЧерезПочту, СтруктураНастроекОбменаДанными.ДанныеНастройки.МаксимальныйРазмерОтправляемогоПакетаЧерезПочту, 
		СтруктураНастроекОбменаДанными.ДанныеНастройки.МаксимальныйРазмерОтправляемогоПолучаемогоПакетаЧерезFTP);*/
			/*// нужно предварительно проанализировать что бы размер отправляемого письма не превосходил ограничений
*/
			if(true/*МаксимальныйДопустимыйРазмерСообщения = 0*/)
			{
			}
			/*// ограничение на размер ответного письма есть, нужно сравнить это значение с размером отправляемого файла
*/
			//ФайлДляОправки = Новый Файл(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений);
			if(true/*ФайлДляОправки.Существует()*/)
			{
				//РазмерОтправляемогоФайла = ФайлДляОправки.Размер();
				if(true/*(РазмерОтправляемогоФайла / 1024) > МаксимальныйДопустимыйРазмерСообщения*/)
				{
					/*// файл превысил допустимый для отправки размер
*/
					/*СообщитьИнформациюОбОшибкеОбмена("Ответный пакет не был отправлен. Размер исходящего пакета составил: " + Окр(РазмерОтправляемогоФайла / 1024, 2) + 
				" (КБт) что превышает допустимое ограничение " + МаксимальныйДопустимыйРазмерСообщения + " (КБт)", 
				СтруктураНастроекОбменаДанными, Истина, Истина);*/
				}
			}
			return null;
		}
		// Процедура выполняет действия после обмена через файловый ресурс

		public void ДействияПослеОбменаЧерезФайловыйРесурс(/*СтруктураНастроекОбменаДанными*/)
		{
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Окончание обмена данными", 5);
			/*// надо файл скопировать обратно из временного каталога в основной			
*/
			if(true/*ОпределитьБылаУдачнноПроизведенаЗаписьДанных(СтруктураНастроекОбменаДанными)*/)
			{
				//ИмяФайла = РаботаСФайлами.ПолучитьИмяФайлаИзПолногоПути(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений);
				//ИмяФайлаДляЗаписиВКаталогОбмена = СтруктураНастроекОбменаДанными.КаталогПроведенияОбменаДанными + "/" + ИмяФайла;
				/*// копируем файл
*/
				/*УдачноеКопирование = ВыполнитьКопированиеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений, ИмяФайлаДляЗаписиВКаталогОбмена, Истина, 
			СтруктураНастроекОбменаДанными, Истина);*/
				if(true/*Не УдачноеКопирование*/)
				{
					//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = Ложь;
				}
			}
			/*// удаляем файлы обмена
*/
			//УдалитьФайлПослеОбменаДанными(СтруктураНастроекОбменаДанными);
		}
		// Процедура выполняет действия после обмена через FTP ресурс

		public void ДействияПослеОбменаЧерезFTPРесурс(/*СтруктураНастроекОбменаДанными*/)
		{
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Окончание обмена данными", 5);
			if(true/*ОпределитьБылаУдачнноПроизведенаЗаписьДанных(СтруктураНастроекОбменаДанными)*/)
			{
				//НужноЗаписатьФайлНаFTP = ОпределитьНужноОптравлятьОтветныйПакет(СтруктураНастроекОбменаДанными, Ложь);
				if(true/*НужноЗаписатьФайлНаFTP*/)
				{
					/*ПроверитьНастройкиПодключения = ПроверитьНастройкиFTPПодключения(СтруктураНастроекОбменаДанными.ДанныеНастройки, 
				СтруктураНастроекОбменаДанными.ДанныеПротокола,	СтруктураНастроекОбменаДанными.ВывестиИнформациюВОкноСообщений, 
				ИмяКаталогаСервера, ИмяFTPСервера, Соединение, СтруктураНастроекОбменаДанными);*/
					if(true/*Не ПроверитьНастройкиПодключения*/)
					{
					}
					//ИмяФайлаFTPЗаписи = ИмяКаталогаСервера + РаботаСФайлами.ПолучитьИмяФайлаИзПолногоПути(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений);
				}
				//ВыполнитьУдалениеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений, СтруктураНастроекОбменаДанными, , Истина);
			}
			/*// удаляем файлы обмена
*/
			//УдалитьФайлПослеОбменаДанными(СтруктураНастроекОбменаДанными);
		}
		// Процедура выполняет действия после обмена через почтовый ресурс

		public void ДействияПослеОбменаЧерезПочтовыйРесурс(/*СтруктураНастроекОбменаДанными*/)
		{
			//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Окончание обмена данными", 5);
			/*// файл записи изменений надо отправить письмом на нужный адрес
*/
			if(true/*ОпределитьБылаУдачнноПроизведенаЗаписьДанных(СтруктураНастроекОбменаДанными)*/)
			{
				//НужноОтправлятьОтветноеПисьмо = ОпределитьНужноОптравлятьОтветныйПакет(СтруктураНастроекОбменаДанными, Истина);
				if(true/*НужноОтправлятьОтветноеПисьмо*/)
				{
					//ДобавитьИнформациюВПротокол("Создание ответного письма", СтруктураНастроекОбменаДанными.ДанныеПротокола);
					//ИмяФайла = РаботаСФайлами.ПолучитьИмяФайлаИзПолногоПути(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений);
					/*// расширение грохаем
*/
					//ПозицияТочки = Найти(ИмяФайла, ".");
					if(true/*ПозицияТочки > 0*/)
					{
						//ИмяШаблонаОбмена = Сред(ИмяФайла, 1, ПозицияТочки - 1);
					}
					/*// формируем и отправляем письмо
*/
					//СтруктураНовогоПисьма = Новый Структура();
					/*// вложения
*/
					//СписокФайловВложений = Новый СписокЗначений;
					//ФайлВложения = СписокФайловВложений.Добавить();
					//СтруктураВложения  = Новый Структура();
					//ДвоичныеДанныеФайла = Новый ДвоичныеДанные(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений);
					//СтруктураВложения.Вставить("Хранилище", ДвоичныеДанныеФайла);
					//СтруктураВложения.Вставить("ИмяФайла", ИмяФайла);
					//ФайлВложения.Значение = СтруктураВложения;
					/*// получатель
*/
					//СписокПолучателей = Новый СписокЗначений();
					/*СписокПолучателей.Добавить(СтруктураНастроекОбменаДанными.ДанныеНастройки.ПочтовыйАдресПолучателя, 
				СтруктураНастроекОбменаДанными.ДанныеНастройки.ПочтовыйАдресПолучателя);*/
					//СтруктураНовогоПисьма.Вставить("Кому", СписокПолучателей);
					//СтруктураНовогоПисьма.Вставить("УчетнаяЗапись", СтруктураНастроекОбменаДанными.ДанныеНастройки.УчетнаяЗаписьПриемаОтправкиСообщений);
					//СтруктураНовогоПисьма.Вставить("Тема", ИмяШаблонаОбмена);
					//СтруктураНовогоПисьма.Вставить("СписокФайловВложений", СписокФайловВложений);
					//СтруктураНовогоПисьма.Вставить("ВидТекста", Перечисления.ВидыТекстовЭлектронныхПисем.Текст);
					/*СтруктураНовогоПисьма.Вставить("Тело", СформироватьТелоПисьмаОбменаМеждуУзлами(СтруктураНастроекОбменаДанными.ТекущийУзелПланаОбмена, 
				СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы));*/
					/*СтруктураПисем = УправлениеЭлектроннойПочтой.НаписатьПисьмо(ПолучитьПользователяДляОтправкиЭлектронныхСообщений(), СтруктураНовогоПисьма, Ложь, Ложь,
							   Ложь, Неопределено, Неопределено, Ложь, ЛОЖЬ);*/
					if(true/*СтруктураПисем <> Неопределено*/)
					{
						//СоответствиеПисем = Новый Соответствие();
						//СсылкаНаПисьмо = Неопределено;
						//СтруктураПисем.Свойство("ПисьмоСсылка", СсылкаНаПисьмо);
						if(true/*ЗначениеЗаполнено(СсылкаНаПисьмо)*/)
						{
							//СоответствиеПисем.Вставить(СсылкаНаПисьмо);
						}
						//СообщитьИнформациюОбОбмене("Отправка исходящего письма", СтруктураНастроекОбменаДанными);
						//ТекстОшибок = "";
						//УправлениеЭлектроннойПочтой.ОтправитьПисьма(СоответствиеПисем, СтруктураНастроекОбменаДанными.СоответствиеТекстовЭлектронныхПисем, ПолучитьПользователяДляОтправкиЭлектронныхСообщений(), Ложь, ТекстОшибок);
						if(true/*НЕ ПустаяСтрока(ТекстОшибок)*/)
						{
							//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = Ложь;
							//СообщитьИнформациюОбОшибкеОбмена("Ошибка при отправке ответного письма: " + ТекстОшибок, СтруктураНастроекОбменаДанными, Истина, Истина);
						}
					}
				}
				//ВыполнитьУдалениеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений, СтруктураНастроекОбменаДанными, , Истина);
			}
			/*// удаляем файлы обмена
*/
			if(true/*ОпределитьБылоУдачноПроизведеноЧтениеДанных(СтруктураНастроекОбменаДанными)*/)
			{
				//ДобавитьИнформациюВПротокол("Пометка обработанных писем как прочтенные", СтруктураНастроекОбменаДанными.ДанныеПротокола);
				/*// если все удачно прочитали, то надо письма обмена пометить как прочитанные
*/
			}
			/*// файл обмена по-любому надо удалить
*/
			//ВыполнитьУдалениеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений, СтруктураНастроекОбменаДанными, , Ложь);
		}
		///////////////////////////////////////////////////////////////////////////////
		// функция формирует тело письма обмена между узлами

		public object СформироватьТелоПисьмаОбменаМеждуУзлами(/*УзелОтправитель, УзелПриемник*/)
		{
			//ИмяПланаОбмена = ПолучитьИмяПланаОбмена(УзелОтправитель);
			/*ТелоПисьма = 
		"	Обмен данными по плану обмена: " + ИмяПланаОбмена + "
		|	Узел отправитель: " + СокрЛП(УзелОтправитель.Код) + "
		|	Узел получатель: " + СокрЛП(УзелПриемник.Код);*/
			return null;
		}
		// Процедура устанавливает необходимость выполнения обмена данными при первом запуске программы

		public void УстановитьНеобходимостьВыполненияОбменаПриПервомЗапускеПрограммы(/*НастройкаОбмена, Знач ВыполнятьОбменПриПервомЗапуске*/)
		{
			if(true/*НастройкаОбмена = Неопределено*/)
			{
			}
			//НаборЗаписейПараметров = РегистрыСведений.ПараметрыОбменаДанными.СоздатьНаборЗаписей();
			//НаборЗаписейПараметров.Отбор.НастройкаОбменаДанными.Установить(НастройкаОбмена);
			//НаборЗаписейПараметров.Прочитать();
			if(true/*НаборЗаписейПараметров.Количество() = 0*/)
			{
				//ЗаписьПараметров = НаборЗаписейПараметров.Добавить();
			}
			//ЗаписьПараметров.НастройкаОбменаДанными = НастройкаОбмена;
			//ЗаписьПараметров.ВыполнятьПриПервомВходеВСистему = ВыполнятьОбменПриПервомЗапуске;
		}
		// Процедура устанавливает необходимость выполнения обмена данными при первом запуске программы

		public void УстановитьДоступностьКаталогаДляПроверки(/*НастройкаОбмена, Знач ДоступностьКаталога*/)
		{
		}

		public void ЗаписатьПараметрыОбменаПоНастройке(/*СсылкаНаНастройкуОбмена,  
	ВыполнятьПриПервомВходеВСистему = Неопределено, ДоступностьКаталогаПроверки = Неопределено,
	ДатаПоследнегоФайлаОбмена = Неопределено*/)
		{
			/*// записываем в объект дату последнего обмена
*/
			//НаборЗаписейПараметров = РегистрыСведений.ПараметрыОбменаДанными.СоздатьНаборЗаписей();
			//НаборЗаписейПараметров.Отбор.НастройкаОбменаДанными.Установить(СсылкаНаНастройкуОбмена);
			//НаборЗаписейПараметров.Прочитать();
			if(true/*НаборЗаписейПараметров.Количество() = 0*/)
			{
				//ЗаписьПараметров = НаборЗаписейПараметров.Добавить();
			}
			//ЗаписьПараметров.НастройкаОбменаДанными = СсылкаНаНастройкуОбмена;
			if(true/*ВыполнятьПриПервомВходеВСистему <> Неопределено*/)
			{
				//ЗаписьПараметров.ВыполнятьПриПервомВходеВСистему = ВыполнятьПриПервомВходеВСистему;
			}
			if(true/*ДоступностьКаталогаПроверки <> Неопределено*/)
			{
				//ЗаписьПараметров.ДоступностьКаталогаПроверки = ДоступностьКаталогаПроверки;
			}
			if(true/*ДатаПоследнегоФайлаОбмена <> Неопределено*/)
			{
				//ЗаписьПараметров.ДатаПоследнегоФайлаОбмена = ДатаПоследнегоФайлаОбмена;
			}
			//НаборЗаписейПараметров.Записать();
		}
		// ФУНКЦИЯ ОБМЕНА ДАННЫМИ ПО НАСТРОЙКЕ

		public void ДобавитьТехническуюИнформацияВСообщение(/*СокращенноеСообщение, СообщениеСТехИнформацией*/)
		{
			if(true/*СокращенноеСообщение = СообщениеСТехИнформацией*/)
			{
			}
			//ЧислоСтрокВСокращенномСообщении = СтрЧислоСтрок(СокращенноеСообщение);
			//ЧислоСтрокВРасширенномСообщении = СтрЧислоСтрок(СообщениеСТехИнформацией);
			//ИтоговаяРасширеннаяСтрока = "";
			//СокращенноеСообщение = СокращенноеСообщение + Символы.ПС + Символы.ПС + "Техническая информация:" + ИтоговаяРасширеннаяСтрока;
		}
		// регистрирует что обмен был произведен и фиксирует информацию в протоколе

		public void ЗафиксироватьЗавершениеОбмена(/*СтруктураДанныхНастройкиОбмена, Знач СтрокаСообщенияОбОшибке = "", 
	Знач НеВыводитьИнформациюПользователю = Ложь, ОбработкаОбменаПриемника = Неопределено*/)
		{
			if(true/*Не ПустаяСтрока(СтрокаСообщенияОбОшибке)*/)
			{
				if(true/*НеВыводитьИнформациюПользователю*/)
				{
					//ДобавитьИнформациюВПротокол(СтрокаСообщенияОбОшибке, СтруктураДанныхНастройкиОбмена.ДанныеПротокола, Ложь, Истина);
				}
			}
			//ИтоговыйКомментарийПриВыгрузкеДанных = ОбщегоНазначения.СформироватьТекстСообщения(СокрЛП(СтрокаСообщенияОбОшибке));
			//ИтоговыйКомнентарийПриВыгрузкеДляТехническогоСпециалиста = СокрЛП(СтрокаСообщенияОбОшибке);
			//ДатаПоследнегоОбмена = ТекущаяДата();
			//СтруктураДанныхНастройкиОбмена.Вставить("ДатаПоследнегоОбмена", ДатаПоследнегоОбмена);
			//СсылкаНаНастройкуОбмена = СтруктураДанныхНастройкиОбмена.ДанныеНастройки.Ссылка;
			//НаборЗаписейИстории = РегистрыСведений.ИсторияОбменаДанными.СоздатьНаборЗаписей();
			//НаборЗаписейИстории.Отбор.УзелИнформационнойБазы.Установить(СтруктураДанныхНастройкиОбмена.ДанныеНастройки.УзелИнформационнойБазы);
			//НаборЗаписейИстории.Отбор.Период.Установить(ДатаПоследнегоОбмена);
			//СтрокаИстории = НаборЗаписейИстории.Добавить();
			//СтрокаИстории.УзелИнформационнойБазы = СтруктураДанныхНастройкиОбмена.ДанныеНастройки.УзелИнформационнойБазы;
			//СтрокаИстории.Период = ДатаПоследнегоОбмена;
			/*// дата и результат последней выгрузки и загрузки
*/
			if(true/*ЗначениеЗаполнено(СтруктураДанныхНастройкиОбмена.ДатаПоследнейЗагрузки)
		И НЕ ПустаяСтрока(СтруктураДанныхНастройкиОбмена.ИмяФайлаЧтенияИзменений)*/)
			{
				//СтрокаИстории.ДатаПоследнейЗагрузки = СтруктураДанныхНастройкиОбмена.ДатаПоследнейЗагрузки;
				//СтрокаИстории.ДатаНачалаПоследнейЗагрузки = СтруктураДанныхНастройкиОбмена.ДатаНачалаЗагрузки;
				//СтрокаИстории.РезультатПоследнейЗагрузки = СтруктураДанныхНастройкиОбмена.РезультатЧтенияДанных;
				//РезультатОтложенныхДвиженийДокументов = Неопределено;
				//СтруктураДанныхНастройкиОбмена.Свойство("РезультатОтложенныхДвиженийДокументов", РезультатОтложенныхДвиженийДокументов);
				//СтрокаИстории.РезультатОтложенныхДвиженийДокументов = РезультатОтложенныхДвиженийДокументов;
				//ОбъектовФонОбмена = Неопределено;
				if(true/*СтруктураДанныхНастройкиОбмена.Свойство("ПолученоОбъектовФоновогоОбмена", ОбъектовФонОбмена)*/)
				{
					//СтрокаИстории.НаличиеДанныхФоновойЗагрузки = ОбъектовФонОбмена > 0;
				}
			}
			//КомментарийПриЗагрузкеДанных = "";
			if(true/*СтруктураДанныхНастройкиОбмена.Свойство("КомментарийПриЗагрузкеДанных", КомментарийПриЗагрузкеДанных)*/)
			{
				//СтрокаИстории.КомментарийКЗагрузкеДанных = ОбщегоНазначения.СформироватьТекстСообщения(СокрЛП(КомментарийПриЗагрузкеДанных));
				if(true/*Не ПустаяСтрока(СтрокаИстории.КомментарийКЗагрузкеДанных) 
			И Не ПустаяСтрока(КомментарийПриЗагрузкеДанных)*/)
				{
					//ДобавитьТехническуюИнформацияВСообщение(СтрокаИстории.КомментарийКЗагрузкеДанных, КомментарийПриЗагрузкеДанных);
				}
				//КоличествоЗагруженныхОбъектов = 0;
				if(true/*ПустаяСтрока(СтрокаИстории.КомментарийКЗагрузкеДанных)
			И СтруктураДанныхНастройкиОбмена.Свойство("КоличествоЗагруженныхОбъектов", КоличествоЗагруженныхОбъектов)*/)
				{
					//СтрокаИстории.КомментарийКЗагрузкеДанных = "Успешно загружено объектов: " + Строка(КоличествоЗагруженныхОбъектов);
				}
			}
			if(true/*ЗначениеЗаполнено(СтруктураДанныхНастройкиОбмена.ДатаПоследнейВыгрузки)
		И НЕ ПустаяСтрока(СтруктураДанныхНастройкиОбмена.ИмяФайлаЗаписиИзменений)*/)
			{
				//СтрокаИстории.ДатаПоследнейВыгрузки = СтруктураДанныхНастройкиОбмена.ДатаПоследнейВыгрузки;
				//СтрокаИстории.ДатаНачалаПоследнейВыгрузки = СтруктураДанныхНастройкиОбмена.ДатаНачалаВыгрузки;
				//СтрокаИстории.РезультатПоследнейВыгрузки = СтруктураДанныхНастройкиОбмена.РезультатЗаписиДанных;
			}
			//КомментарийПриВыгрузкеДанных = "";
			if(true/*СтруктураДанныхНастройкиОбмена.Свойство("КомментарийПриВыгрузкеДанных", КомментарийПриВыгрузкеДанных)*/)
			{
				//ИтоговыйКомментарийПриВыгрузкеДанных = СокрЛП(ИтоговыйКомментарийПриВыгрузкеДанных + Символы.ПС + ОбщегоНазначения.СформироватьТекстСообщения(СокрЛП(КомментарийПриВыгрузкеДанных)));
				//ИтоговыйКомнентарийПриВыгрузкеДляТехническогоСпециалиста = СокрЛП(ИтоговыйКомнентарийПриВыгрузкеДляТехническогоСпециалиста + Символы.ПС + СокрЛП(КомментарийПриВыгрузкеДанных));
				//КоличествоВыгруженныхОбъектов = 0;
				if(true/*ПустаяСтрока(ИтоговыйКомментарийПриВыгрузкеДанных)
			И СтруктураДанныхНастройкиОбмена.Свойство("КоличествоВыгруженныхОбъектов", КоличествоВыгруженныхОбъектов)*/)
				{
					if(true/*КоличествоВыгруженныхОбъектов <> 0*/)
					{
						//ИтоговыйКомментарийПриВыгрузкеДанных = "Успешно выгружено объектов: " + Строка(КоличествоВыгруженныхОбъектов);
					}
				}
			}
			//СтрокаИстории.КомментарийКВыгрузкеДанных = ИтоговыйКомментарийПриВыгрузкеДанных;
			if(true/*Не ПустаяСтрока(СтрокаИстории.КомментарийКВыгрузкеДанных) 
		И Не ПустаяСтрока(ИтоговыйКомнентарийПриВыгрузкеДляТехническогоСпециалиста)*/)
			{
				//ДобавитьТехническуюИнформацияВСообщение(СтрокаИстории.КомментарийКВыгрузкеДанных, ИтоговыйКомнентарийПриВыгрузкеДляТехническогоСпециалиста);
			}
			//КомментарийПриВыполненииОтложенныхДвижений = "";
			//КоличествоВыполненныхОтложенныхДвиженийДокументов = 0;
			if(true/*СтруктураДанныхНастройкиОбмена.Свойство("КомментарийПриВыполненииОтложенныхДвижений", КомментарийПриВыполненииОтложенныхДвижений)*/)
			{
				//СтрокаИстории.КомментарийКОтложенномуДвижениюДокументов = СокрЛП(КомментарийПриВыполненииОтложенныхДвижений);
			}
			/*// надо изменения отразить в обработке автоматического поиска
*/
			if(true/*СтруктураДанныхНастройкиОбмена.ОбработкаАвтоОбменДанными <> Неопределено
		И  СтруктураДанныхНастройкиОбмена.ДанныеНастройкиАвтообмена <> Неопределено*/)
			{
				/*СтруктураДанныхНастройкиОбмена.ОбработкаАвтоОбменДанными.ОбновитьИнформациюОНастройкахОбмена(СтруктураДанныхНастройкиОбмена.ДанныеНастройкиАвтообмена.Ссылка, 
			СтруктураДанныхНастройкиОбмена.ДоступностьКаталогаПроверки);*/
			}
			//ЗаписатьДанныеПротокола(СтруктураДанныхНастройкиОбмена.ДанныеНастройки, СтруктураДанныхНастройкиОбмена.ДанныеПротокола, НЕ ПустаяСтрока(СтрокаСообщенияОбОшибке));
			if(true/*СтруктураДанныхНастройкиОбмена.РучнойРежимЗапуска
		И СтруктураДанныхНастройкиОбмена.ДанныеНастройкиАвтообмена = Неопределено*/)
			{
				/*// для On Line обменов показываем отдельную форму завершения обмена
*/
				//ФормаПоказа = ПолучитьОбщуюФорму("ФормаРезультатOnLineОбмена");
				//ФормаПоказа.НаборЗаписейИстории = НаборЗаписейИстории;
				//ФормаПоказа.Открыть();
			}
		}
		// Процедура корректирует паузу перед запуском регламентного задания

		public void ИзменитьВремяПаузыПовтораРегламентногоЗадания(/*СтруктураНастроекОбменаДанными, ДатаНачалаВыполненияОбменов*/)
		{
			if(true/*СтруктураНастроекОбменаДанными = Неопределено*/)
			{
			}
			/*// изменяем время только при автообмене
*/
			if(true/*СтруктураНастроекОбменаДанными.РучнойРежимЗапуска
		ИЛИ НЕ СтруктураНастроекОбменаДанными.ДинамическиИзменятьИнтервалМеждуОбменами*/)
			{
			}
			if(true/*ТекущееРегламентноеЗадание = Неопределено*/)
			{
			}
			//РасписаниеРегламентногоЗадания = ТекущееРегламентноеЗадание.Расписание;
			if(true/*РасписаниеРегламентногоЗадания.ПериодПовтораВТечениеДня = 0*/)
			{
			}
			//ПродолжительностьПоследнегоОбмена = ТекущаяДата() - ДатаНачалаВыполненияОбменов;
			//НовоеЗначениеПаузыПовтора = ПродолжительностьПоследнегоОбмена + Окр(РасписаниеРегламентногоЗадания.ПериодПовтораВТечениеДня / 2, 0);
			/*// органичим паузу повтора... что бы не было 100 кратного превышения повтора в течении дня
*/
			//НовоеЗначениеПаузыПовтора = Мин(НовоеЗначениеПаузыПовтора, РасписаниеРегламентногоЗадания.ПериодПовтораВТечениеДня * 100);
			//РасписаниеРегламентногоЗадания.ПаузаПовтора = НовоеЗначениеПаузыПовтора;
		}
		// Процедура возвращает параметры для обмена

		public void ПолучитьПараметрыОбменаДанными(/*СтруктураНастроекОбменаДанными, МетаданныеУзлаОбмена, СтрокаИнформацияОбОбмене*/)
		{
			/*// получаем узел информационной базы плана обмена
*/
			//ИмяПланаОбмена = ПолучитьИмяПланаОбмена(СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы);
			//МетаданныеУзлаОбмена = СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы.Метаданные();
			//СтрокаОписанияЗапуска = ?(СтруктураНастроекОбменаДанными.РучнойРежимЗапуска, "в интерактивном режиме", "в автоматическом режиме");
			//СтрокаИнформацияОбОбмене = "обмена данными " + СтрокаОписанияЗапуска + " для плана обмена """ + ИмяПланаОбмена + """ узла """ + СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы.Наименование + """";
		}
		//Функция проводит необходимые действия перед началом обмена данными
		// возвращает нужно ли производить обмен или нет

		public object ВыполнитьДействияПередНачаломОбменаДанными(/*СтруктураНастроекОбменаДанными*/)
		{
			//СообщитьИнформациюОбОбмене(Символы.ПС, СтруктураНастроекОбменаДанными);
			/*// информация об обмене данными
*/
			if(true/*СтруктураНастроекОбменаДанными.РучнойРежимЗапуска*/)
			{
				//СтрокаЗаписиВЛогПриНачалеОбмена = "Начат обмен данными";
			}
			//СтрокаЗаписиВЛогПриНачалеОбмена = СтрокаЗаписиВЛогПриНачалеОбмена + " по настройке """ + Строка(СтруктураНастроекОбменаДанными.ДанныеНастройки) + """ (" + Формат(ТекущаяДата(), "ДЛФ=В") + ").";
			//СообщитьИнформациюОбОбмене(СтрокаЗаписиВЛогПриНачалеОбмена, СтруктураНастроекОбменаДанными);
			if(true/*НЕ ЗначениеЗаполнено(СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы)*/)
			{
				//ЗафиксироватьЗавершениеОбмена(СтруктураНастроекОбменаДанными, "В настройке обмена не задан узел информационной базы с которым нужно производить обмен информацией! Обмен отменен.");
			}
			if(true/*НЕ СтруктураНастроекОбменаДанными.ПроизводитьЧтениеДанных 
		И НЕ СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных*/)
			{
				//ЗафиксироватьЗавершениеОбмена(СтруктураНастроекОбменаДанными, "В настройке обмена не взведены флаги загрузки и выгрузки данных! Обмен отменен.");
			}
			//МетаданныеУзлаОбмена = Неопределено;
			//СтрокаИнформацияОбОбмене = "";
			//ПолучитьПараметрыОбменаДанными(СтруктураНастроекОбменаДанными, МетаданныеУзлаОбмена, СтрокаИнформацияОбОбмене);
			//СтруктураНастроекОбменаДанными.Вставить("ТекущийУзелПланаОбмена", ПланыОбмена[МетаданныеУзлаОбмена.Имя].ЭтотУзел());
			/*// сами с собой не обмениваемся
*/
			if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы = СтруктураНастроекОбменаДанными.ТекущийУзелПланаОбмена*/)
			{
				//ЗафиксироватьЗавершениеОбмена(СтруктураНастроекОбменаДанными, "Нельзя организовать обмен данными с текущим узлом информационной базы! Обмен отменен.");
			}
			/*// у узлов участвующих в обмене должен быть не пустой код
*/
			if(true/*ПустаяСтрока(Строка(СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы.Код)) 
		ИЛИ ПустаяСтрока(Строка(СтруктураНастроекОбменаДанными.ТекущийУзелПланаОбмена.Код))*/)
			{
				//ЗафиксироватьЗавершениеОбмена(СтруктураНастроекОбменаДанными, "Нельзя организовать обмен данными когда один из узлов обмена имеет пустой код! Обмен отменен.");
			}
			/*// записываем в журнал данные о начале обмена данными
*/
			/*ЗаписьЖурналаРегистрации("Обмен данными.Автоматический", УровеньЖурналаРегистрации.Информация, 
		МетаданныеУзлаОбмена, СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы, "Начало " + СтрокаИнформацияОбОбмене);*/
			return null;
		}
		//функция выполняется после завершения обменом данными

		public object ВыполнитьДействияПослеЗавершенияОбменаДанными(/*СтруктураНастроекОбменаДанными, ОбработкаОбменаПриемника = Неопределено*/)
		{
			//МетаданныеУзлаОбмена = Неопределено;
			//СтрокаИнформацияОбОбмене = "";
			//ПолучитьПараметрыОбменаДанными(СтруктураНастроекОбменаДанными, МетаданныеУзлаОбмена, СтрокаИнформацияОбОбмене);
			/*// отмечаем то что обмен произведен
*/
			/*СообщитьИнформациюОбОбмене("Обмен данными по настройке """ + Строка(СтруктураНастроекОбменаДанными.ДанныеНастройки) + """ завершен (" + Формат(ТекущаяДата(), "ДЛФ=В") + ").", 
		СтруктураНастроекОбменаДанными);*/
			//ЗафиксироватьЗавершениеОбмена(СтруктураНастроекОбменаДанными, , , ОбработкаОбменаПриемника);
			/*// записываем в журнал данные об окончании обмена данными
*/
			/*ЗаписьЖурналаРегистрации("Обмен данными.Автоматический", УровеньЖурналаРегистрации.Информация, 
		МетаданныеУзлаОбмена, СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы, "Окончание " + СтрокаИнформацияОбОбмене);*/
			//ЗаписатьДанныеПротокола(СтруктураНастроекОбменаДанными.ДанныеНастройки, СтруктураНастроекОбменаДанными.ДанныеПротокола, Ложь);
			//ЗакрытьФормуОбработкиДанных(СтруктураНастроекОбменаДанными);
			return null;
		}

		public void ВыполнитьОбычныйОбменДанными(/*СтруктураНастроекОбменаДанными*/)
		{
			if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.ТипНастройки = Перечисления.ТипыАвтоматическогоОбменаДанными.ОбменЧерезФайловыйРесурс*/)
			{
				//СтруктураНастроекОбменаДанными.Вставить("КаталогПроведенияОбменаДанными", "");
				//СтруктураНастроекОбменаДанными.Вставить("ИмяВходящегоФайлаОбмена", "");
				//ПодготовитьОбменЧерезФайловыйРесурс(СтруктураНастроекОбменаДанными);
			}
			/*// файл для записи изменений
*/
			if(true/*СтруктураНастроекОбменаДанными.НеобходимостьЗаписиОтветногоФайлаОбмена*/)
			{
				//СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений = ВерутьИмяВременногоФайлаЗаписиДанных(СтруктураНастроекОбменаДанными);
				if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.ВыполнятьАрхивациюФайловОбмена*/)
				{
					//РаботаСФайлами.УстановитьРасширениеФайла(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений, ".zip");
				}
			}
			/*// если ничего делать не надо, то выходим вообще
*/
			if(true/*ПустаяСтрока(СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений)
		И ПустаяСтрока(СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений)*/)
			{
				//СообщитьИнформациюОбОбмене("Ни загрузка ни выгрузка данных не были произведены", СтруктураНастроекОбменаДанными);
				//ОтправитьСообщениеОбОшибкеОбменаПриНеобходимости(СтруктураНастроекОбменаДанными);
			}
			/*// САМ ОБМЕН ДАННЫМИ
*/
			//ВыполнитьЗагрузкуДанныхИзФайлаОбмена(СтруктураНастроекОбменаДанными);
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЗаписьТолькоПриУспешномЧтении*/)
			{
				/*СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных = СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных
			И СтруктураНастроекОбменаДанными.ПроизводитьЗаписьТолькоПриУспешномЧтении
			И СтруктураНастроекОбменаДанными.РезультатЧтенияДанных;*/
			}
			//ВыполнитьВыгрузкуДанныхВФайлОбмена(СтруктураНастроекОбменаДанными);
			/*// ДЕЙСТВИЯ ПОСЛЕ ОБМЕНА
*/
			if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.ТипНастройки = Перечисления.ТипыАвтоматическогоОбменаДанными.ОбменЧерезФайловыйРесурс*/)
			{
				//ДействияПослеОбменаЧерезФайловыйРесурс(СтруктураНастроекОбменаДанными);
			}
			if(true/*Не СтруктураНастроекОбменаДанными.РучнойРежимЗапуска
		И СтруктураНастроекОбменаДанными.ДоступностьФайла = Истина*/)
			{
				/*// нет ли обновления конфигурации по РИБ
*/
				//КонфигурацияПриОбменеРИБИзменена = Ложь;
				//СтруктураНастроекОбменаДанными.Свойство("КонфигурацияПриОбменеРИБИзменена", КонфигурацияПриОбменеРИБИзменена);
				if(true/*КонфигурацияПриОбменеРИБИзменена = Неопределено
			ИЛИ КонфигурацияПриОбменеРИБИзменена = Ложь*/)
				{
					//ВыполнитьУдалениеФайла(СтруктураНастроекОбменаДанными.ВыполнятьОбменПриПоявленииФайла, СтруктураНастроекОбменаДанными, , Истина);
				}
			}
		}

		public void УстановитьПараметрыCOMСоединенияСПриемником(/*ОбработкаОбменаДаннымиXML, ДанныеНастройки*/)
		{
			//ОбработкаОбменаДаннымиXML.ТипИнформационнойБазыДляПодключения = ДанныеНастройки.ТипИнформационнойБазыДляПодключения;
			//ОбработкаОбменаДаннымиXML.КаталогИнформационнойБазыДляПодключения = ДанныеНастройки.КаталогИнформационнойБазыДляПодключения;
			//ОбработкаОбменаДаннымиXML.ИмяСервераИнформационнойБазыДляПодключения = ДанныеНастройки.ИмяСервераИнформационнойБазыДляПодключения;
			//ОбработкаОбменаДаннымиXML.ИмяИнформационнойБазыНаСервереДляПодключения = ДанныеНастройки.ИмяИнформационнойБазыНаСервереДляПодключения;
			//ОбработкаОбменаДаннымиXML.АутентификацияWindowsИнформационнойБазыДляПодключения = ДанныеНастройки.АутентификацияWindowsИнформационнойБазыДляПодключения;
			//ОбработкаОбменаДаннымиXML.ПользовательИнформационнойБазыДляПодключения = ДанныеНастройки.ПользовательИнформационнойБазыДляПодключения;
			//ОбработкаОбменаДаннымиXML.ПарольИнформационнойБазыДляПодключения = ДанныеНастройки.ПарольИнформационнойБазыДляПодключения;
			//ОбработкаОбменаДаннымиXML.ВерсияПлатформыИнформационнойБазыДляПодключения = ДанныеНастройки.ВерсияПлатформыИнформационнойБазыДляПодключения;
		}

		public object СформироватьЕдиныйКоментарий(/*ОбработкаОбмена, ИнформацияОбОшибкеВыполнения*/)
		{
			if(true/*ОбработкаОбмена = Неопределено*/)
			{
			}
			//Комментарий = СокрЛП(ОбработкаОбмена.КомментарийПриВыгрузкеДанных + Символы.ПС + ОбработкаОбмена.КомментарийПриЗагрузкеДанных);
			if(true/*ОбработкаОбмена.мОбработкаДляЗагрузкиДанных <> Неопределено*/)
			{
				if(true/*ЗначениеЗаполнено(ОбработкаОбмена.мОбработкаДляЗагрузкиДанных.КомментарийПриВыгрузкеДанных)
			ИЛИ ЗначениеЗаполнено(ОбработкаОбмена.мОбработкаДляЗагрузкиДанных.КомментарийПриЗагрузкеДанных)*/)
				{
					/*Комментарий = Комментарий + Символы.ПС + "Сообщение информационной базы с которой организован обмен:" + Символы.ПС +
				СокрЛП(ОбработкаОбмена.мОбработкаДляЗагрузкиДанных.КомментарийПриВыгрузкеДанных + Символы.ПС + ОбработкаОбмена.мОбработкаДляЗагрузкиДанных.КомментарийПриЗагрузкеДанных);*/
				}
			}
			if(true/*Не ЗначениеЗаполнено(Комментарий)*/)
			{
			}
			if(true/*Не ЗначениеЗаполнено(ИнформацияОбОшибкеВыполнения)*/)
			{
			}
			return null;
		}

		public void ДополнитьКомментарийДляОперации(/*СтруктураНастроекОбменаДанными, Комментарий, ЭтоВыгрузкаДанных = Истина*/)
		{
			if(true/*СтруктураНастроекОбменаДанными = Неопределено
		ИЛИ ПустаяСтрока(Комментарий)*/)
			{
			}
			//ТекущийКоммнетарий = "";
			if(true/*ЭтоВыгрузкаДанных*/)
			{
				//СтруктураНастроекОбменаДанными.Свойство("КомментарийПриВыгрузкеДанных", ТекущийКоммнетарий);
			}
			if(true/*ЗначениеЗаполнено(ТекущийКоммнетарий)*/)
			{
				//ТекущийКоммнетарий = ТекущийКоммнетарий + Символы.ПС + Комментарий;
			}
			if(true/*ЭтоВыгрузкаДанных*/)
			{
				//СтруктураНастроекОбменаДанными.Вставить("КомментарийПриВыгрузкеДанных", ТекущийКоммнетарий);
			}
		}

		public object ОпределитьУзелОбменаИнформационнойБазыПриемника(/*ОбработкаОбменаПриемника, УзелОбмена*/)
		{
			if(true/*Не ЗначениеЗаполнено(УзелОбмена)*/)
			{
			}
			//ИмяПланаОбмена = ПолучитьИмяПланаОбмена(УзелОбмена);
			//КодУзла = ПланыОбмена[ИмяПланаОбмена].ЭтотУзел().Код;
			return null;
		}

		public void ВыполнитьОбменДаннымиЧерезComСоединение(/*СтруктураНастроекОбменаДанными, ОбработкаОбменаПриемника = Неопределено*/)
		{
			//ИнициализироватьФормуХодаОбработки(СтруктураНастроекОбменаДанными, "Подготовка перед обменом данными", 5);
			//СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов = "";
			//СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументаВПриемнике = "";
			//РезультатВыполненияОтложенныхДвижений = Неопределено;
			//РезультатВыполненияОтложенныхДвиженийВПриемнике = Неопределено;
			//СтруктураНастроекОбменаДанными.РезультатЧтенияДанных = Ложь;
			//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = Ложь;
			//ОбработкаОбменаДаннымиXML = Обработки.ОбменДаннымиXML.Создать();
			//ОбработкаОбменаДаннымиXML.ВыполнитьОтложенноеПроведениеДокументовПослеЗагрузкиДанных = СтруктураНастроекОбменаДанными.ВыполнитьОтложенноеПроведениеДокументовПослеЗагрузкиДанных;
			/*// устанавливаем соm-соединение
*/
			//УстановитьПараметрыCOMСоединенияСПриемником(ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными.ДанныеНастройки);
			//СтрокаСообщенияОбОшибке = "";
			//ОбработкаОбменаДаннымиXML.мОбработкаДляЗагрузкиДанных = Неопределено;
			//ОбъектПодключения = Неопределено;
			//ОбработкаОбменаДаннымиXML.мОбработкаДляЗагрузкиДанных = ОбработкаОбменаДаннымиXML.ВыполнитьПодключениеКИБПриемнику(ОбработкаОбменаДаннымиXML.мОбработкаДляЗагрузкиДанных, СтрокаСообщенияОбОшибке, ОбъектПодключения);
			if(true/*Не ПустаяСтрока(СтрокаСообщенияОбОшибке)*/)
			{
				//КомментарийПриЗагрузкеДанных = СформироватьЕдиныйКоментарий(ОбработкаОбменаДаннымиXML, СтрокаСообщенияОбОшибке);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, КомментарийПриЗагрузкеДанных, Ложь);
			}
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЧтениеДанных*/)
			{
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Подготовка перед загрузкой данных", 5);
				/*// выгрузка из приемника в текущую ИБ
*/
				//ОбработкаОбменаПриемника = ОбработкаОбменаДаннымиXML.мОбработкаДляЗагрузкиДанных;
				if(true/*ОбработкаОбменаПриемника = Неопределено*/)
				{
				}
				//ОбработкаОбменаПриемника.УзелДляФоновогоОбмена = ОпределитьУзелОбменаИнформационнойБазыПриемника(ОбъектПодключения, СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелФоновогоОбмена);
				//ОбработкаОбменаПриемника.УзелДляОбмена = ОпределитьУзелОбменаИнформационнойБазыПриемника(ОбъектПодключения, СтруктураНастроекОбменаДанными.ДанныеНастройки.УзелИнформационнойБазы);
				//УстановитьПараметрыДляВыгрузкиДанныхXML(ОбработкаОбменаПриемника, СтруктураНастроекОбменаДанными, Ложь);
				//ОбработкаОбменаПриемника.мОбработкаДляЗагрузкиДанных = ОбработкаОбменаДаннымиXML;
				//СтрокаСообщенияОбОшибке = "";
				//РезультатПодключения = ОбработкаОбменаПриемника.ВыполнитьПодключениеКИБПриемнику(ОбработкаОбменаПриемника.мОбработкаДляЗагрузкиДанных, СтрокаСообщенияОбОшибке);
				if(true/*РезультатПодключения = Неопределено*/)
				{
					//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, СтрокаСообщенияОбОшибке, Ложь);
				}
				//ОбработкаОбменаПриемника.НепосредственноеЧтениеВИБПриемнике = Истина;
				//ОбработкаОбменаПриемника.ДописыватьДанныеВПротоколОбмена = Истина;
				//СтруктураНастроекОбменаДанными.ДатаНачалаЗагрузки = ТекущаяДата();
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Загрузка данных из информационной базы - источника", 5);
				//СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов = "";
				/*УспешнаяВыгрузкаИзПриемника = ОбработкаОбменаПриемника.ВыполнитьВыгрузку(Истина, СтрокаСообщенияОбОшибке, 
			СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов, 
			СтруктураНастроекОбменаДанными.ДанныеНастройки.ПослеОшибкиОтложенногоПроведенияПрекратитьОперации, СтруктураНастроекОбменаДанными.ДанныеНастройки.КоличествоОшибокОтложенногоПроведенияДляПрекращенияОперации);*/
				if(true/*Не ПустаяСтрока(СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов)*/)
				{
					//СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов = "Отложенные движения документов в этой информационной базе:" + Символы.ПС + СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов;
				}
				//РезультатВыполненияОтложенныхДвижений = ОбработкаОбменаДаннымиXML.РезультатВыполненияОтложенныхДвижений;
				//КомментарийПриЗагрузкеДанных = СформироватьЕдиныйКоментарий(ОбработкаОбменаДаннымиXML, СтрокаСообщенияОбОшибке);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, КомментарийПриЗагрузкеДанных, Ложь);
				//СтруктураНастроекОбменаДанными.Вставить("ПолученоОбъектовФоновогоОбмена", ОбработкаОбменаДаннымиXML.ПолученоОбъектовФоновогоОбмена);
				//СтруктураНастроекОбменаДанными.Вставить("КоличествоВыполненныхОтложенныхДвиженийДокументов", ОбработкаОбменаДаннымиXML.мКоличествоВыполненныхОтложенныхДвиженийДокументов);
				//СтруктураНастроекОбменаДанными.Вставить("КоличествоЗагруженныхОбъектов", ОбработкаОбменаДаннымиXML.мСчетчикЗагруженныхОбъектов);
				//СтруктураНастроекОбменаДанными.ДатаПоследнейЗагрузки = ТекущаяДата();
				//СтруктураНастроекОбменаДанными.РезультатЧтенияДанных = УспешнаяВыгрузкаИзПриемника;
			}
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЗаписьТолькоПриУспешномЧтении*/)
			{
				/*СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных = СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных
			И СтруктураНастроекОбменаДанными.ПроизводитьЗаписьТолькоПриУспешномЧтении
			И СтруктураНастроекОбменаДанными.РезультатЧтенияДанных;*/
			}
			if(true/*СтруктураНастроекОбменаДанными.ПроизводитьЗаписьДанных*/)
			{
				//СтруктураНастроекОбменаДанными.ДатаНачалаВыгрузки = ТекущаяДата();
				//УстановитьПараметрыДляВыгрузкиДанныхXML(ОбработкаОбменаДаннымиXML, СтруктураНастроекОбменаДанными);
				//ОбработкаОбменаДаннымиXML.НепосредственноеЧтениеВИБПриемнике = Истина;
				//ОтобразитьНовоеСообщениеВФормеХодаОбработки(СтруктураНастроекОбменаДанными, "Выгрузка данных в информационную базу - приемник", 40);
				/*// выгрузка из текущей ИБ в приемник
*/
				//СтрокаСообщенияОбОшибке = "";
				/*УспешнаяВыгрузкаИзИсточника = ОбработкаОбменаДаннымиXML.ВыполнитьВыгрузку(Истина, СтрокаСообщенияОбОшибке, 
			СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументаВПриемнике, 
			СтруктураНастроекОбменаДанными.ДанныеНастройки.ПослеОшибкиОтложенногоПроведенияПрекратитьОперации, 
			СтруктураНастроекОбменаДанными.ДанныеНастройки.КоличествоОшибокОтложенногоПроведенияДляПрекращенияОперации);*/
				if(true/*Не ПустаяСтрока(СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументаВПриемнике)*/)
				{
					//РезультатВыполненияОтложенныхДвиженийВПриемнике = Ложь;
					if(true/*СтруктураНастроекОбменаДанными.ДанныеНастройки.ТипИнформационнойБазыДляПодключения = Истина*/)
					{
						/*// приемник - файловая ИБ
*/
						//СтрокаПараметровПодключенияКПриемнику = "Каталог информационной базы: " + СтруктураНастроекОбменаДанными.ДанныеНастройки.КаталогИнформационнойБазыДляПодключения;
					}
					/*СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументаВПриемнике = "Отложенные движения документов в информационной базе ПРИЕМНИКЕ:" + Символы.ПС + 
				"Подключение к информационной базе ПРИЕМНИКА: " + СтрокаПараметровПодключенияКПриемнику + Символы.ПС + 
				СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументаВПриемнике;*/
				}
				//КомментарийПриВыгрузкеДанных = СформироватьЕдиныйКоментарий(ОбработкаОбменаДаннымиXML, СтрокаСообщенияОбОшибке);
				//ДополнитьКомментарийДляОперации(СтруктураНастроекОбменаДанными, КомментарийПриВыгрузкеДанных, Истина);
				//СтруктураНастроекОбменаДанными.Вставить("ПереданоОбъектовФоновогоОбмена", ОбработкаОбменаДаннымиXML.ПереданоОбъектовФоновогоОбмена);
				//СтруктураНастроекОбменаДанными.Вставить("КоличествоВыгруженныхОбъектов", ОбработкаОбменаДаннымиXML.мСчетчикВыгруженныхОбъектов);
				//СтруктураНастроекОбменаДанными.ДатаПоследнейВыгрузки = ТекущаяДата();
				//СтруктураНастроекОбменаДанными.ИмяФайлаЗаписиИзменений = "1";
				//СтруктураНастроекОбменаДанными.РезультатЗаписиДанных = УспешнаяВыгрузкаИзИсточника;
			}
			//СтруктураНастроекОбменаДанными.ИмяФайлаЧтенияИзменений = "1";
			if(true/*ПустаяСтрока(СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументаВПриемнике)*/)
			{
				//ИтоговыйКомментарийПриОтложенномДвиженииДокументов = СтрокаСообщенияОбОшибкеОтложенныеДвиженияДокументов;
			}
			//СтруктураНастроекОбменаДанными.Вставить("КомментарийПриВыполненииОтложенныхДвижений", ИтоговыйКомментарийПриОтложенномДвиженииДокументов);
			//ИтоговыйРезультатОтложенныхДвижений = Неопределено;
			if(true/*РезультатВыполненияОтложенныхДвиженийВПриемнике = Неопределено*/)
			{
				//ИтоговыйРезультатОтложенныхДвижений = РезультатВыполненияОтложенныхДвижений;
			}
			//СтруктураНастроекОбменаДанными.Вставить("РезультатОтложенныхДвиженийДокументов", ИтоговыйРезультатОтложенныхДвижений);
			//ОптравитьСообщениеОбОшибкеДействийСОтложеннымПроведениемДокументов(СтруктураНастроекОбменаДанными, ИтоговыйКомментарийПриОтложенномДвиженииДокументов);
		}
		// Процедура поизводит обмен данными по настройке обмена

		public void ПроизвестиОбменДаннымиПоНастройке(/*СтруктураНастроекОбменаДанными*/)
		{
			/*// начальные функции инициализации обмена
*/
			//РезультатаНачалаОбмена = ВыполнитьДействияПередНачаломОбменаДанными(СтруктураНастроекОбменаДанными);
			if(true/*Не РезультатаНачалаОбмена*/)
			{
			}
			/*// ВЫПОЛНЕНИЕ ОБМЕНА ДАННЫМИ
*/
			//ОбработкаОбменаПриемника = Неопределено;
			//ОбработкаОбменаПриемника = Неопределено;
			//Состояние("");
		}

		public void ОтправитьСообщениеОбОшибкеПриПредыдущемВыполнении(/*СтруктураНастроекОбмена*/)
		{
			if(true/*СтруктураНастроекОбмена.РучнойРежимЗапуска*/)
			{
			}
			//ОбъектНастройки = СтруктураНастроекОбмена.ДанныеНастройкиАвтообмена;
			if(true/*ТекущееРегламентноеЗадание = Неопределено*/)
			{
			}
		}

		public object ПолучитьБазовуюСтруктуруПараметровОбмена(/*РучнойРежимЗапуска, ОбработкаАвтоОбменДанными, 
	ОбменПриВходеВПрограмму, СоответствиеТекстовЭлектронныхПисем*/)
		{
			//СтруктураНастроекОбмена = Новый Структура();
			//СтруктураНастроекОбмена.Вставить("РучнойРежимЗапуска", РучнойРежимЗапуска);
			//СтруктураНастроекОбмена.Вставить("ОбработкаАвтоОбменДанными", ОбработкаАвтоОбменДанными);
			//СтруктураНастроекОбмена.Вставить("ОбменПриВходеВПрограмму", ОбменПриВходеВПрограмму);
			//СтруктураНастроекОбмена.Вставить("СоответствиеТекстовЭлектронныхПисем", СоответствиеТекстовЭлектронныхПисем);
			//СтруктураНастроекОбмена.Вставить("ДанныеПротокола", "");
			//СтруктураНастроекОбмена.Вставить("ДатаПоследнегоФайлаОбмена", Неопределено);
			//СтруктураНастроекОбмена.Вставить("ДатаНачалаЗагрузки", Неопределено);
			//СтруктураНастроекОбмена.Вставить("ДатаНачалаВыгрузки", Неопределено);
			//СтруктураНастроекОбмена.Вставить("ДатаПоследнейЗагрузки", Неопределено);
			//СтруктураНастроекОбмена.Вставить("ДатаПоследнейВыгрузки", Неопределено);
			//СтруктураНастроекОбмена.Вставить("ИмяФайлаЧтенияИзменений", "");
			//СтруктураНастроекОбмена.Вставить("ИмяФайлаЗаписиИзменений", "");
			//СтруктураНастроекОбмена.Вставить("РезультатЧтенияДанных", Ложь);
			//СтруктураНастроекОбмена.Вставить("РезультатЗаписиДанных", Ложь);
			//СтруктураНастроекОбмена.Вставить("КомментарийПриЗагрузкеДанных", "");
			//СтруктураНастроекОбмена.Вставить("КомментарийПриВыгрузкеДанных", "");
			//СтруктураНастроекОбмена.Вставить("ВывестиИнформациюОбОшибкеВОкноСообщений", Истина);
			//СтруктураНастроекОбмена.Вставить("ВывестиИнформациюВОкноСообщений", Истина);
			//СтруктураНастроекОбмена.Вставить("НеобходимостьЗаписиОтветногоФайлаОбмена", Ложь);
			//СтруктураНастроекОбмена.Вставить("ДанныеНастройкиАвтообмена", Неопределено);
			//СтруктураНастроекОбмена.Вставить("ДоступностьКаталогаПроверки", Неопределено);
			return null;
		}

		public void ДополнитьСтруктуруОбменаПоАвтоматическойНастройкеОбмена(/*СтруктураНастроекОбмена, ОбъектНастройки*/)
		{
			//СтруктураНастроекОбмена.Вставить("ДанныеНастройкиАвтообмена", ОбъектНастройки);
			//ДоступностьФайла = Неопределено;
			if(true/*Не ПустаяСтрока(ОбъектНастройки.ВыполнятьОбменПриПоявленииФайла)*/)
			{
				//ДоступностьФайла = ПроверитьНаличиеКаталога(ОбъектНастройки.ВыполнятьОбменПриПоявленииФайла);
			}
			//ДоступностьКаталога = Неопределено;
			if(true/*Не ПустаяСтрока(ОбъектНастройки.КаталогПроверкиДоступности)*/)
			{
				//ДоступностьКаталога = ПроверитьНаличиеКаталога(ОбъектНастройки.КаталогПроверкиДоступности);
			}
			//СтруктураНастроекОбмена.Вставить("ДоступностьКаталогаПроверки", ДоступностьКаталога);
			//СтруктураНастроекОбмена.Вставить("ПроизводитьЗаписьТолькоПриУспешномЧтении", Ложь);
			//СтруктураНастроекОбмена.Вставить("ДоступностьФайла", ДоступностьФайла);
			//СтруктураНастроекОбмена.Вставить("ВыполнятьОбменПриПоявленииФайла", ОбъектНастройки.ВыполнятьОбменПриПоявленииФайла);
			//СтруктураНастроекОбмена.Вставить("КоличествоЭлементовВТранзакцииНаВыгрузкуДанных", ОбъектНастройки.КоличествоЭлементовВТранзакцииНаВыгрузкуДанных);
			//СтруктураНастроекОбмена.Вставить("КоличествоЭлементовВТранзакцииНаЗагрузкуДанных", ОбъектНастройки.КоличествоЭлементовВТранзакцииНаЗагрузкуДанных);
			//СтруктураНастроекОбмена.Вставить("УчетнаяЗаписьОтправкиСообщенияОбОшибке", ОбъектНастройки.УчетнаяЗаписьОтправкиСообщенияОбОшибке);
			//СтруктураНастроекОбмена.Вставить("АдресДляОтправкиСообщенийОбОшибке", ОбъектНастройки.АдресДляОтправкиСообщенийОбОшибке);
			//СообщенияНеЯвляющиесяОшибками = ОбъектНастройки.СообщенияНеЯвляющиесяОшибками.Выгрузить();
			//СтруктураНастроекОбмена.Вставить("СообщенияНеЯвляющиесяОшибками", СообщенияНеЯвляющиесяОшибками);
			//СтруктураНастроекОбмена.Вставить("ДинамическиИзменятьИнтервалМеждуОбменами", ОбъектНастройки.ДинамическиИзменятьИнтервалМеждуОбменами);
		}

		public object ПолучитьСоответствиеПользовательскихПолейПоискаПоНастройке(/*ОбъектНастройки, ДанныеПоискаДляВыгрузки*/)
		{
			//СоответствиеПользовательскихПолей = Новый Соответствие();
			//СтрокиТЧ = ОбъектНастройки.НастройкаВариантовПоискаОбъектов.НайтиСтроки(Новый Структура("ЭтоНастройкаДляВыгрузки", ДанныеПоискаДляВыгрузки));
			if(true/*СтрокиТЧ <> Неопределено
		И СтрокиТЧ.Количество() <> 0*/)
			{
			}
			return null;
		}

		public object ПолучитьСоответствиеНастроекВыгрузкиЗагрузки(/*ОбъектНастройки, ДанныеПоискаДляВыгрузки*/)
		{
			//СоответствиеПользовательскихПолей = Новый Соответствие();
			//СтрокиТЧ = ОбъектНастройки.НастройкаВыгрузкиДанных.НайтиСтроки(Новый Структура("ЭтоНастройкаДляВыгрузки", ДанныеПоискаДляВыгрузки));
			if(true/*СтрокиТЧ <> Неопределено
		И СтрокиТЧ.Количество() <> 0*/)
			{
			}
			return null;
		}

		public void ДополнитьСтруктуруОбменаПоПростойНастройкеОбмена(/*СтруктураНастроекОбмена, ОбъектНастройки, ДобавлятьВсеНастройки = Истина*/)
		{
			//СтруктураНастроекОбмена.Вставить("ДанныеНастройки", ОбъектНастройки);
			//СтруктураНастроекОбмена.Вставить("ВыполнитьОтложенноеПроведениеДокументовПослеЗагрузкиДанных", НЕ ОбъектНастройки.ВыполнитьОтложенноеПроведениеДокументовПоРасписанию);
			/*//помещаем в структуру информацию по выбранным настройкам для сопоставления объектов при выгрузке и загрузке данных	
*/
			//ИнформацияСопоставленияДляВыгрузки = ПолучитьСоответствиеПользовательскихПолейПоискаПоНастройке(ОбъектНастройки, Истина);
			//ИнформацияСопоставленияДляЗагрузки = ПолучитьСоответствиеПользовательскихПолейПоискаПоНастройке(ОбъектНастройки, Ложь);
			//СтруктураНастроекОбмена.Вставить("ИнформацияСопоставленияДляВыгрузки", ИнформацияСопоставленияДляВыгрузки);
			//СтруктураНастроекОбмена.Вставить("ИнформацияСопоставленияДляЗагрузки", ИнформацияСопоставленияДляЗагрузки);
			/*//пользовательские настройки выгрузки и загрузки данных	
*/
			//ИнформацияОбъектовДляВыгрузки = ПолучитьСоответствиеНастроекВыгрузкиЗагрузки(ОбъектНастройки, Истина);
			//ИнформацияОбъектовДляЗагрузки = ПолучитьСоответствиеНастроекВыгрузкиЗагрузки(ОбъектНастройки, Ложь);
			//СтруктураНастроекОбмена.Вставить("ИнформацияОбъектовДляВыгрузки", ИнформацияОбъектовДляВыгрузки);
			//СтруктураНастроекОбмена.Вставить("ИнформацияОбъектовДляЗагрузки", ИнформацияОбъектовДляЗагрузки);
			if(true/*ДобавлятьВсеНастройки*/)
			{
				//СтруктураНастроекОбмена.Вставить("ПроизводитьЧтениеДанных", ОбъектНастройки.ПроизводитьПриемСообщений);
				//СтруктураНастроекОбмена.Вставить("ПроизводитьЗаписьДанных", ОбъектНастройки.ПроизводитьОтправкуСообщений);
				/*ПроизводитьЗаписьТолькоПриУспешномЧтении = ОбъектНастройки.ПроизводитьПриемСообщений
			И ОбъектНастройки.ПроизводитьОтправкуСообщений
			И ОбъектНастройки.ПроизводитьОтправкуТолькоПриУспешномПриеме;*/
				//СтруктураНастроекОбмена.Вставить("ПроизводитьЗаписьТолькоПриУспешномЧтении", ПроизводитьЗаписьТолькоПриУспешномЧтении);
				//СтруктураНастроекОбмена.Вставить("ДоступностьФайла", Ложь);
				//СтруктураНастроекОбмена.Вставить("ВыполнятьОбменПриПоявленииФайла", "");
				//СтруктураНастроекОбмена.Вставить("КоличествоЭлементовВТранзакцииНаВыгрузкуДанных", ОбъектНастройки.КоличествоЭлементовВТранзакцииНаВыгрузкуДанных);
				//СтруктураНастроекОбмена.Вставить("КоличествоЭлементовВТранзакцииНаЗагрузкуДанных", ОбъектНастройки.КоличествоЭлементовВТранзакцииНаЗагрузкуДанных);
				//СтруктураНастроекОбмена.Вставить("УчетнаяЗаписьОтправкиСообщенияОбОшибке", ОбъектНастройки.УчетнаяЗаписьОтправкиСообщенияОбОшибке);
				//СтруктураНастроекОбмена.Вставить("АдресДляОтправкиСообщенийОбОшибке", ОбъектНастройки.АдресДляОтправкиСообщенийОбОшибке);
				//СообщенияНеЯвляющиесяОшибками = ОбъектНастройки.СообщенияНеЯвляющиесяОшибками.Выгрузить();
				//СтруктураНастроекОбмена.Вставить("СообщенияНеЯвляющиесяОшибками", СообщенияНеЯвляющиесяОшибками);
				//СтруктураНастроекОбмена.Вставить("ДинамическиИзменятьИнтервалМеждуОбменами", Ложь);
			}
		}
		// АВТОМАТИЧЕСКИЙ ОБМЕН ДАННЫМИ
		///////////////////////////////////////////////////////////////////////////////

		public object ВыполнитьОтложенныеДвиженияПоПараметрам(/*УзелОбмена, 
	ПрекратитьПроведениеДокументовВСлучаеОшибки, КоличествоОшибокОбменаДляПрекращенияПроведения, 
	ФормаОтображения = Неопределено*/)
		{
			//СтрокаСообщенияОбОшибкеОтложенногоДвиженияДокументов = "";
			//ОбработкаОбменаДаннымиXML.ЗавершитьВедениеПротоколаОбмена();
			return null;
		}

		public void ВыполнитьОтложенныеДвиженияПоНастройкеОбмена(/*НастройкаОбменаДанными, ФормаОтображения = Неопределено*/)
		{
			/*ВыполнитьОтложенныеДвиженияПоПараметрам(НастройкаОбменаДанными.УзелИнформационнойБазы, 
		НастройкаОбменаДанными.ПослеОшибкиОтложенногоПроведенияПрекратитьОперации, 
		НастройкаОбменаДанными.КоличествоОшибокОтложенногоПроведенияДляПрекращенияОперации,
		ФормаОтображения);*/
		}

		public void ВыполнитьОбменПоНастройке(/*НастройкаОбменаДанными, РучнойЗапускОбменов = Истина, 
	ОбработкаАвтообменаНаКлиенте = Неопределено, Знач СоответствиеТекстовЭлектронныхПисем = Неопределено, Знач ОбменПриВходеВПрограмму = Ложь*/)
		{
			//ОбъектНастройки = НастройкаОбменаДанными.ПолучитьОбъект();
			if(true/*ОбъектНастройки = Неопределено*/)
			{
			}
			/*// производится непосредственно сам обмен данными
*/
			/*СтруктураНастроекОбмена = ПолучитьБазовуюСтруктуруПараметровОбмена(РучнойЗапускОбменов, ОбработкаАвтообменаНаКлиенте, 
		ОбменПриВходеВПрограмму, СоответствиеТекстовЭлектронныхПисем);*/
			//ДополнитьСтруктуруОбменаПоПростойНастройкеОбмена(СтруктураНастроекОбмена, ОбъектНастройки);
			/*// выполнение обмена данными по конкретной настройке обмена
*/
			//ПроизвестиОбменДаннымиПоНастройке(СтруктураНастроекОбмена);
		}

		public void ВыполнитьОбменПоНастройкеАвтоматическогоОбмена(/*НастройкаОбменаДанными, РучнойЗапускОбменов = Истина, 
	ОбработкаАвтообменаНаКлиенте = Неопределено, Знач СоответствиеТекстовЭлектронныхПисем = Неопределено, Знач ОбменПриВходеВПрограмму = Ложь*/)
		{
			//ОбъектНастройки = НастройкаОбменаДанными.ПолучитьОбъект();
			if(true/*ОбъектНастройки = Неопределено*/)
			{
			}
			//ДатаНачалаВыполненияОбмена = ТекущаяДата();
			//ИзменитьВремяПаузыПовтораРегламентногоЗадания(СтруктураНастроекОбмена, ДатаНачалаВыполненияОбмена);
		}

		public void ВыполнитьОбменДаннымиПоПроизвольнойНастройке(/*НастройкаОбменаДанными, РучнойЗапускОбменов = Истина, 
	ОбработкаАвтообменаНаКлиенте = Неопределено, Знач СоответствиеТекстовЭлектронныхПисем = Неопределено, Знач ОбменПриВходеВПрограмму = Ложь*/)
		{
			if(true/*ТипЗнч(НастройкаОбменаДанными) = Тип("СправочникСсылка.НастройкиОбменаДанными")*/)
			{
				if(true/*НЕ ЗначениеЗаполнено(НастройкаОбменаДанными)*/)
				{
				}
				/*// как выполнять обмен, под полными правами или нет
*/
				if(true/*НастройкаОбменаДанными.ВыполнятьДействияПодПолнымиПравами*/)
				{
					//ИнформационнаяБазаФайловая = ОпределитьЭтаИнформационнаяБазаФайловая();
					if(true/*НЕ ИнформационнаяБазаФайловая*/)
					{
						//Сообщить("Начат обмен данными под полными правами на сервере 1С:Предприятия по настройке """ + Строка(НастройкаОбменаДанными) + """ " + ТекущаяДата() + Символы.ПС);
					}
					/*ПроцедурыОбменаДаннымиПолныеПрава.ВыполнитьОбменДаннымиПоНастройкеОбменаПодПолнымиПравамиНаСервере(НастройкаОбменаДанными, РучнойЗапускОбменов, 
				Неопределено, Неопределено, ОбменПриВходеВПрограмму);*/
					if(true/*НЕ ИнформационнаяБазаФайловая*/)
					{
						//Сообщить("Завершен обмен данными под полными правами на сервере 1С:Предприятия по настройке """ + Строка(НастройкаОбменаДанными) + """ " + ТекущаяДата() + Символы.ПС);
					}
				}
			}
		}

		public void ВыполнитьОбменПоНастройкеАвтоматическогоВыполненияОбменаДанными(/*НастройкаОбменаДанными, РучнойЗапускОбменов = Истина, ОбработкаАвтообменаНаКлиенте = Неопределено, 
	Знач СоответствиеТекстовЭлектронныхПисем = Неопределено, Знач ОбменПриВходеВПрограмму = Ложь*/)
		{
			if(true/*ТипЗнч(НастройкаОбменаДанными) <> Тип("СправочникСсылка.НастройкиВыполненияОбмена")*/)
			{
			}
			if(true/*НЕ ЗначениеЗаполнено(НастройкаОбменаДанными)*/)
			{
			}
			/*// как выполнять обмен, под полными правами или нет
*/
			if(true/*НастройкаОбменаДанными.ВыполнятьДействияПодПолнымиПравами*/)
			{
				//ИнформационнаяБазаФайловая = ОпределитьЭтаИнформационнаяБазаФайловая();
				if(true/*НЕ ИнформационнаяБазаФайловая*/)
				{
					//Сообщить("Начат обмен данными под полными правами на сервере 1С:Предприятия по настройке автоматического обмена """ + Строка(НастройкаОбменаДанными) + """ " + ТекущаяДата() + Символы.ПС);
				}
				/*ПроцедурыОбменаДаннымиПолныеПрава.ВыполнитьОбменДаннымиПоНастройкеАвтоматическогоОбменаПодПолнымиПравамиНаСервере(НастройкаОбменаДанными, РучнойЗапускОбменов, 
			Неопределено, Неопределено, ОбменПриВходеВПрограмму);*/
				if(true/*НЕ ИнформационнаяБазаФайловая*/)
				{
					//Сообщить("Завершен обмен данными под полными правами на сервере 1С:Предприятия по настройке автоматического обмена """ + Строка(НастройкаОбменаДанными) + """ " + ТекущаяДата() + Символы.ПС);
				}
			}
		}

		public object ВыполнитьИнициализациюАвтообменаПриНачалеРаботы(/**/)
		{
			/*// автообмен данными
*/
			if(true/*ПравоДоступа("Использование", Метаданные.Обработки.АвтоОбменДанными)*/)
			{
				/*// производим отложенный обмен при первом входе в программу
*/
				//ОбработкаАвтоОбменДанными = Обработки.АвтоОбменДанными.Создать();
				/*// обмен при первом входе
*/
				//ОбработкаАвтоОбменДанными.ПроизвестиОбменПриВходеВыходе(Истина);
				/*// отдельно получаем настройки для которых нужно выполнить обмен при входе в программу
*/
				//ОбработкаАвтоОбменДанными.ПроизвестиОбменПриВходеВыходе(, Истина);
				/*// получаем данные периодического обмена данными и с ними работаем
*/
				//ОбработкаАвтоОбменДанными.ОбновитьТабличнуюЧастьАвтоматическихОбменов();
			}
			return null;
		}
		// выполнение обмена данными при завершении работы программы

		public void ВыполнитьОбменПриЗавершенииРаботыПрограммы(/*ОбработкаОбмена*/)
		{
			if(true/*(ОбработкаОбмена <> Неопределено)*/)
			{
				/*// отдельно получаем настройки для которых нужно выполнить обмен при выходе из программы
*/
				//ОбработкаОбмена.ПроизвестиОбменПриВходеВыходе( ,, Истина);
			}
		}

		public void ПередЗаписьюДокументаПроверкаНаличияВОтложенныхДвиженияхПередЗаписью(/*Источник, Отказ, РежимЗаписи, РежимПроведения*/)
		{
			if(true/*Источник.ЭтоНовый()
		ИЛИ РежимЗаписи <> РежимЗаписиДокумента.Запись*/)
			{
			}
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ ПЕРВЫЕ 1 1
	|	
	|ИЗ
	|	РегистрСведений.ОтложенныеДвиженияДокументов КАК ОтложенныеДвиженияДокументов
	|ГДЕ
	|	ОтложенныеДвиженияДокументов.Документ = &Ссылка";*/
			//Запрос.УстановитьПараметр("Ссылка", Источник.Ссылка);
			//РезультатЗапроса = Запрос.Выполнить();
			if(true/*РезультатЗапроса.Пустой()*/)
			{
			}
			/*Сообщить(Строка(Источник) + Символы.ПС + "
		         |Записывается документ, присутствующий в списке отложенных к проведению.
		         |Запись может повлечь за собой отмену проведения документа в других информационных базах!
		         |Рекомендуется провести документ!");*/
		}
	}
}
